// Surface 6 — Assessments // // Authors the pre-/post-assessment. State lives in `courseSettings.assessments` // (owned by app.jsx, persisted to IndexedDB with the rest of the draft, mapped // to the server by `buildCourseSettings`), so nothing here is lost on // navigation and everything visible reaches the exported ZIP. // // Shape — mirrors `AssessmentsSchema` in @dynamo/schema field-for-field, with // ONE deliberate difference: a group's `moduleId` holds the FE's string module // id ('M1'), because that is what the UI works with. `buildCourseSettings` // resolves it to the numeric `ModuleSchema.id` at export. Storing the number // here would break the moment a module is renumbered. // // assessments = { // randomiseGroupOrder: bool, // ONE course-wide flag (see below) // pre: { enabled, groups: [...] }, // post: { enabled, groups: [...] }, // } // group = { moduleId, questionsShown, questions: [...], uid } // question = { prompt, answers: [...], correctFeedback, wrongFeedback, uid } // answer = { text, correct, wrongFeedback, uid } // // `uid` is FE-only (a stable React key). `buildCourseSettings` builds a clean // object and never forwards it. // // WHAT THIS SURFACE DELIBERATELY DOES NOT OFFER, and why — each verified // against the pinned Player, not inferred: // // - **Mode / Pass mark.** The runtime's threshold mode still reports // `cmi.success_status = "passed"` to the LMS on the FAIL path // (`scripts.js:8824` — it never writes "failed" anywhere), and it silently // disables module filtering (`scripts.js:1113`). All five reference // packages ship completion mode. Offering a pass mark would be a // compliance gate that does not gate. // - **Background image.** Only applied when `fancyAssessment` is on AND it // needs a path-prefix class (`content/` with no language segment) the // packager cannot express. Nothing would be bundled. // - **Per-question / per-answer images.** The pinned runtime parses answer // images but the line that DRAWS them is commented out // (`scripts.js:4431`) — an author would upload and see nothing. // - ~~**AI "Generate questions".**~~ **REAL as of 2026-08-10.** The old panel // fabricated plausible question text behind a fake 700 ms pause and was removed // for it. `AssessmentGeneratePanel` below is the genuine article: it POSTs the // module's own authored text to `POST /v1/generate-questions`, which calls // OpenAI with the pinned prompt at `prompts/generate/question_generator.md`. // Every returned question must satisfy the four-answer shape // (wiki/concepts/four-answer-shape.md) or it is DROPPED and counted, twice — // once in the route, once here before the merge — because `PUT /draft` is // all-or-nothing and one malformed question would 400 the whole course. // Generation writes the DEFAULT language only, per Omar's decision; the // existing Translate flow fills the rest. // - **A per-learner shuffle switch.** The Player ALWAYS draws the K questions // at random, per learner, per attempt (`scripts.js:9271-9276`) — there is // no flag to turn it off. An "off" switch would be the false affordance. // The Show-K-of-N hint says so in words instead. // - **Per-question roles.** One `default` role exists today; role scoping is // campaign Stage 5. // // `randomiseGroupOrder` is course-wide on purpose: despite being emitted as // ``, the Player applies it to BOTH assessments (the // shuffle sits in the generator shared by pre and post, `scripts.js:7019`). function SurfaceAssessments({ course, settings, setSettings, onNavigate, layoutDrafts }) { const [tab, setTab] = React.useState('pre'); const modules = (course && course.modules) || []; const assessments = (settings && settings.assessments) || ASSESSMENT_EMPTY; const phase = assessments[tab] || { enabled: false, groups: [] }; // One writer for the whole slice. Every mutation below funnels through it, // so there is exactly one place where assessment state reaches app.jsx. const patchAssessments = React.useCallback((fn) => { setSettings(prev => { const current = (prev && prev.assessments) || ASSESSMENT_EMPTY; return { ...prev, assessments: fn(current) }; }); }, [setSettings]); const patchPhase = React.useCallback((which, fn) => { patchAssessments(a => { const p = a[which] || { enabled: false, groups: [] }; return { ...a, [which]: fn(p) }; }); }, [patchAssessments]); return (
{/* The shared page header (2026-08-14). This screen used to be a 52px bar with a 14px title and no sentence — its own idea of a header, on a screen that sits beside five others. `SurfaceHeader` is the one style now. */} {/* SHORT, because this header carries more than the others: a save door AND the pre/post switcher. The first sentence written here was the same length as Content mapping's and rendered with an ellipsis — measured, not guessed. The room a description has is a property of the screen, not of the component. */} Questions asked before the course and after it.}>
setTab('pre')}> Pre-assessment{assessments.pre?.enabled ? ' ·' : ''} setTab('post')}> Post-assessment{assessments.post?.enabled ? ' ·' : ''}
{/* Main column */}
patchPhase(tab, p => ({ ...p, enabled: v }))} onToggleRandomise={(v) => patchAssessments(a => ({ ...a, randomiseGroupOrder: v }))} /> {/* AI generation, on BOTH tabs: it writes into whichever assessment is open, which is what "generate the questions" means when you are looking at one of them. */} patchPhase(tab, p => { const groups = (p.groups || []).map(g => g); perModule.forEach(({ moduleId, questions }) => { // Questions arrive already shaped and already filtered twice; the // only thing left is to give them the FE-only `uid` React needs. const withUids = questions.map(q => ({ ...q, uid: window.assessmentOpsUid('q'), answers: (q.answers || []).map(a => ({ ...a, uid: window.assessmentOpsUid('a') })), })); let at = -1; for (let i = 0; i < groups.length; i++) { if (groups[i].moduleId === moduleId) { at = i; break; } } if (at === -1) { groups.push({ uid: window.assessmentOpsUid('g'), moduleId, questionsShown: Math.min(withUids.length, Math.max(1, withUids.length)), questions: withUids, }); return; } // His rule: all-modules REPLACES, one module ADDS. const kept = mode === 'replace' ? [] : (groups[at].questions || []); const next = kept.concat(withUids); groups[at] = { ...groups[at], questions: next, // Re-clamp: a group whose pool shrank under a replace would // otherwise keep a K larger than the pool. questionsShown: Math.max(1, Math.min( groups[at].questionsShown || 1, next.length)) }; }); return { ...p, groups }; })} /> {/* Omar, 2026-08-10: "Once the pre-assessment is done, there has to be a button which enable the Admin to reflect the same questions also on the post-assessment." So it lives on the PRE tab, where he described reaching for it. The safety is in the dialog, which states what it would overwrite before anything happens. */} {tab === 'pre' && ( patchAssessments(a => { const next = window.copyPreToPost(a, mode, moduleIds); return alsoEnable ? { ...next, post: { ...next.post, enabled: true } } : next; })} /> )} patchPhase(tab, fn)} />
{/* Right sidebar */}
); } // Save to the server. The debounced autosave only writes IndexedDB, and the // only other caller of `dynamoSaveDraftToServer` is the layout editor's Save — // so an author who wrote a whole assessment and never opened a layout had // nothing on the server until they pressed Build. That is fine until they // switch machine or clear the browser. // Now a thin wrapper over the ONE shared implementation (`components.jsx` // `DraftSaveButton`). It used to be its own hand-written copy, near-identical to // `LocSaveToServer` in surface-localisation.jsx — and when two more screens // needed the same control on 2026-08-11, a hand-copied fourth would have been how // four buttons quietly stopped behaving alike. `dirtySignal` is new here: the old // copy had none, so its green "Saved" persisted over questions edited afterwards. function AssessmentSaveButton({ dirtySignal }) { // `idleLabel={null}` was passed explicitly here while the shared default was // "Saved on this device"; the default is now null for everyone, so keeping it on // exactly one of the four call sites would imply the other three differ. return ; } const ASSESSMENT_EMPTY = { randomiseGroupOrder: true, pre: { enabled: false, groups: [] }, post: { enabled: false, groups: [] }, }; let _assessUid = 0; const assessmentUid = (p) => `${p}-${Date.now().toString(36)}-${_assessUid++}`; const assessmentClamp = (v, lo, hi) => Math.max(lo, Math.min(hi, v)); function assessmentNewAnswer(correct = false) { return { uid: assessmentUid('a'), text: {}, correct, wrongFeedback: {} }; } function assessmentNewQuestion() { return { uid: assessmentUid('q'), prompt: {}, answers: [assessmentNewAnswer(true), assessmentNewAnswer(false)], correctFeedback: {}, wrongFeedback: {}, }; } function assessmentNewGroup(moduleId) { return { uid: assessmentUid('g'), moduleId, questionsShown: 1, questions: [] }; } function TabBtn({ active, children, onClick }) { return ( ); } // ── Toggle — small switch with an onChange + tooltip (unlike the bare Switch, // ── which owns its own state). // Named `AssessmentToggle` (not `Toggle`) to avoid clobbering the canonical // controlled `Toggle` in field-widgets.jsx — both files share global scope, so // a bare `function Toggle` here shadowed the value-based one the layout editors // rely on (e.g. quiz_gaming Scoring), making those switches render stuck-off. function AssessmentToggle({ on, onChange, title }) { return ( ); } // ── Phase card — the on/off switch that drives /, // ── plus the one course-wide shuffle flag. function AssessmentPhaseCard({ which, phase, randomise, onToggleEnabled, onToggleRandomise }) { const isPre = which === 'pre'; const total = (phase.groups || []).reduce((n, g) => n + (g.questions || []).length, 0); return (

{isPre ? 'Include a pre-assessment' : 'Include a post-assessment'}

{isPre ? 'Learners answer these before the modules open. Getting a module’s questions right marks that module as already known.' : 'Learners answer these after finishing every module. Getting a module’s questions right passes that module.'}

{phase.enabled ? 'On' : 'Off'}
{phase.enabled && total === 0 && (
This is switched on but has no questions yet, so the export will stop and say so. Add questions below, or switch it back off.
)}
Shuffle group order

Changes the order the modules’ question groups appear in. This one setting applies to both the pre- and the post-assessment — the course format only has room for one.

); } // ── Group list — one question group per module, plus the orphan warning. ───── function AssessmentGroupList({ which, phase, modules, onPatchPhase }) { const [confirm, setConfirm] = React.useState(null); const [openGroups, setOpenGroups] = React.useState({}); // Which question rows are expanded. Held HERE rather than inside the row so // "Add question" can open the new one — a row that appears collapsed and // empty reads as "nothing happened". const [openQuestions, setOpenQuestions] = React.useState({}); const groups = phase.groups || []; const byId = new Map(modules.map(m => [m.id, m])); const bound = new Set(groups.map(g => g.moduleId)); const unbound = modules.filter(m => !bound.has(m.id)); // A group whose module has since been deleted. It cannot be exported (the // mapper can only resolve real modules), so say so rather than let the // author keep editing questions that will never ship. const orphans = groups.filter(g => !byId.has(g.moduleId)); const mapGroup = (uid, fn) => onPatchPhase(p => ({ ...p, groups: p.groups.map(g => g.uid === uid ? fn(g) : g) })); const patchGroup = (uid, patch) => mapGroup(uid, g => ({ ...g, ...patch })); const removeGroup = (uid) => onPatchPhase(p => ({ ...p, groups: p.groups.filter(g => g.uid !== uid) })); const addGroup = (moduleId) => { const g = assessmentNewGroup(moduleId); setOpenGroups(o => ({ ...o, [g.uid]: true })); onPatchPhase(p => ({ ...p, groups: [...p.groups, g] })); }; const addGroupsForAll = () => { if (!unbound.length) return; const fresh = unbound.map(m => assessmentNewGroup(m.id)); setOpenGroups(o => ({ ...o, [fresh[0].uid]: true })); onPatchPhase(p => ({ ...p, groups: [...p.groups, ...fresh] })); }; const mapQuestions = (gid, fn) => mapGroup(gid, g => { const questions = fn(g.questions || []); // Keep K within the pool automatically — an author who deletes questions // should not have to go and fix a number to make the export pass. return { ...g, questions, questionsShown: assessmentClamp(g.questionsShown || 1, 1, Math.max(1, questions.length)) }; }); const doConfirm = () => { if (!confirm) return; if (confirm.kind === 'group') removeGroup(confirm.uid); if (confirm.kind === 'question') { mapQuestions(confirm.gid, qs => qs.filter(q => q.uid !== confirm.uid)); } setConfirm(null); }; return (
{orphans.length > 0 && (
{orphans.length} question group{orphans.length === 1 ? '' : 's'} point at a module that no longer exists

Their questions cannot be included in the course. Remove them, or add the module back.

{orphans.map(g => ( ))}
)} {unbound.length > 0 && (
{unbound.length === 1 ? '1 module has no questions in this assessment' : `${unbound.length} modules have no questions in this assessment`}

A module without questions simply isn’t assessed — it won’t stop the export. Add a group for any module you want to test.

{unbound.map(m => ( ))} {unbound.length > 1 && ( )}
)}

Question groups

{groups.length}
{groups.length === 0 ? (
No questions yet. Pick a module above to start writing questions for it.
) : (
{groups.map(g => ( setOpenGroups(o => ({ ...o, [g.uid]: !o[g.uid] }))} onPatch={patch => patchGroup(g.uid, patch)} onDelete={() => setConfirm({ kind: 'group', uid: g.uid, label: locText((byId.get(g.moduleId) || {}).title) || g.moduleId, count: (g.questions || []).length })} openQuestions={openQuestions} onToggleQuestion={(quid) => setOpenQuestions(o => ({ ...o, [quid]: !o[quid] }))} onAddQuestion={() => { const q = assessmentNewQuestion(); setOpenQuestions(o => ({ ...o, [q.uid]: true })); mapQuestions(g.uid, qs => [...qs, q]); }} onPatchQuestion={(quid, patch) => mapQuestions(g.uid, qs => qs.map(q => q.uid === quid ? { ...q, ...patch } : q))} onDeleteQuestion={(quid) => setConfirm({ kind: 'question', gid: g.uid, uid: quid })} /> ))}
)} {confirm && confirm.kind === 'group' && ( 0 ? `This also removes ${confirm.count} question${confirm.count === 1 ? '' : 's'}. This can't be undone.` : "This can't be undone."} confirmLabel="Delete group" onConfirm={doConfirm} onCancel={() => setConfirm(null)} /> )} {confirm && confirm.kind === 'question' && ( setConfirm(null)} /> )}
); } function AssessmentGroupCard({ group, module, open, onToggleOpen, onPatch, onDelete, onAddQuestion, onPatchQuestion, onDeleteQuestion, openQuestions, onToggleQuestion }) { const questions = group.questions || []; const N = questions.length; const label = module ? locText(module.title) : 'Module removed'; return (
{open && (
onPatch({ questionsShown: v })} /> {N === 0 && (
No questions in this group yet.
)} {questions.map((q, i) => ( onToggleQuestion(q.uid)} onPatch={patch => onPatchQuestion(q.uid, patch)} onDelete={() => onDeleteQuestion(q.uid)} /> ))}
)}
); } // ── Ask K of N. Writing more questions than you ask is the point: the Player // ── draws a different set for every learner, on every attempt. function AssessmentCountField({ questionsShown, total, onChange }) { const max = Math.max(1, total); const val = assessmentClamp(questionsShown ?? 1, 1, max); return (
Ask onChange(assessmentClamp(parseInt(e.target.value, 10) || 1, 1, max))} style={{ width: 56, height: 28, fontSize: 12.5, textAlign: 'center' }} /> of {total}
{total > val ? `Each learner is asked ${val} of these ${total} questions, picked at random — a different set each attempt.` : 'Write more questions than you ask and each learner gets a different, randomly picked set.'}
); } function AssessmentQuestionRow({ num, question, expanded, onToggleExpanded, onPatch, onDelete }) { const lang = React.useContext(LocDefaultLangContext) || 'en'; const promptText = locText(question.prompt, lang); const answers = question.answers || []; const correctCount = answers.filter(a => a.correct === true).length; // The Player has exactly two question shapes and picks by counting correct // answers — there is no author-facing control, and inventing one would let // the two disagree. const kind = correctCount > 1 ? 'Select all that apply' : 'One correct answer'; const patchAnswer = (uid, patch) => onPatch({ answers: answers.map(a => a.uid === uid ? { ...a, ...patch } : a) }); return (
Q{num} {promptText || 'Untitled question'} {answers.length} answers {correctCount === 0 ? : }
{expanded && (
onPatch({ prompt: v })} placeholder="Type the question…" style={{ fontSize: 13 }} />
Answers · {kind}
{correctCount === 0 && (
Tick the correct answer. Without one, a learner can never pass this module.
)} {correctCount > 1 && answers.some(a => a.correct !== true && locText(a.wrongFeedback, lang)) && (
On a “select all that apply” question the course player can’t tell which single answer to respond to, so per-answer notes aren’t shown — everyone who gets it wrong sees the “Feedback after a wrong answer” message below.
)}
{answers.map((a, i) => ( patchAnswer(a.uid, patch)} onDelete={answers.length > 2 ? () => onPatch({ answers: answers.filter(x => x.uid !== a.uid) }) : null} /> ))}
onPatch({ correctFeedback: v })} placeholder="Explain why this is right…" /> onPatch({ wrongFeedback: v })} placeholder="Shown for any wrong answer that has no note of its own…" />
)}
); } function AssessmentAnswerRow({ letter, answer, onPatch, onDelete }) { const [showNote, setShowNote] = React.useState(false); const lang = React.useContext(LocDefaultLangContext) || 'en'; const hasNote = !!locText(answer.wrongFeedback, lang); return (
{letter}
onPatch({ text: v })} placeholder="Answer text…" style={{ fontSize: 12.5 }} />
{(!answer.correct || hasNote) && ( )} {onDelete && ( )}
{(showNote || hasNote) && !(answer.correct && !hasNote) && (
{answer.correct && hasNote && (
This answer is now ticked correct, so this note is never shown. Clear it or untick the answer — it is left visible so it can’t sit in the course unseen.
)} onPatch({ wrongFeedback: v })} multiline placeholder="Why this particular answer is wrong…" style={{ fontSize: 12, minHeight: 44 }} />
)}
); } // ── Result screen — NOT authorable in this version, and honest about it. // The wording lives in the per-language UI.xml files bundled with the Player // (15 languages, ~14 separate label slots including three variants of the body // depending on how the learner did in the pre-assessment). Making it editable // is its own slice of work; a text box here would write to nothing. function AssessmentResultScreenNote({ which, onNavigate }) { return (

Result screen

The {which === 'pre' ? '“thank you”' : '“well done”'} screen learners see at the end uses the course player’s built-in wording, already translated into every language you can enable.

Editing that wording per course isn’t available yet — it lives in a different part of the package from the questions. Your questions, answers and feedback are fully translatable on the Localisation screen.

{onNavigate && ( )}
); } Object.assign(window, { SurfaceAssessments }); // ── Copy the pre-assessment onto the post-assessment ───────────────────────── // // Omar, 2026-08-10 (verbatim in wiki/Pre_Post_Assessment_design.md §2-prime Q1'): // // > "The copy button should enable the admin to either copy the whole // > pre-assessments questions onto the post, or only speicifc modules. If the // > there are existing post-assessment questions the system should ask whether // > to replace or to keep them. In case the admin keep the post-asses qeustions // > the new pre-asses questions will be added on top." // // Two axes, both his choice at press time: SCOPE and COLLISION BEHAVIOUR. The // dialog therefore asks rather than assuming, and states the consequence in // counts before the button is live — a copy that silently replaced authored // questions would be the kind of quiet loss this project has already paid for. // // All the arithmetic lives in `assessment-ops-core.js` so CI can execute it; this // component only renders it. function AssessmentCopyToPostBar({ assessments, modules, onCopy }) { const [open, setOpen] = React.useState(false); const full = window.copyPreToPostPlan(assessments); const [picked, setPicked] = React.useState(null); // null = "all", else array const [mode, setMode] = React.useState('replace'); const [alsoEnable, setAlsoEnable] = React.useState(true); const [done, setDone] = React.useState(null); const nameOf = (id) => { const m = modules.find(x => x.id === id); return m ? `${id} · ${locText(m.title) || 'Untitled'}` : id; }; const candidates = full.rows.map(r => r.moduleId); const selection = picked === null ? candidates : picked; const plan = window.copyPreToPostPlan(assessments, selection); if (!candidates.length) { return (
Write some pre-assessment questions and you'll be able to copy them straight onto the post-assessment from here.
); } const toggle = (id) => setPicked(p => { const cur = p === null ? candidates.slice() : p.slice(); const at = cur.indexOf(id); if (at === -1) cur.push(id); else cur.splice(at, 1); return cur; }); return (
Reflect onto the post-assessment
{full.totalCopying} question{full.totalCopying === 1 ? '' : 's'} across{' '} {candidates.length} module{candidates.length === 1 ? '' : 's'} can be copied.
{done && ( {done} )}
{open && ReactDOM.createPortal(
setOpen(false)}>
e.stopPropagation()} className="card" style={{ width: 560, maxWidth: 'calc(100vw - 32px)', maxHeight: 'calc(100vh - 64px)', overflowY: 'auto', padding: 18, boxShadow: 'var(--shadow-xl)' }}>

Copy the pre-assessment onto the post-assessment

Pick the modules to copy. Nothing changes until you press Copy.

{/* SCOPE — "the whole pre-assessments questions … or only specific modules" */}
Modules
{full.rows.map(r => ( ))}
{/* Modules an author might EXPECT to be copied but which have nothing. */} {full.skippedEmpty.length > 0 && (

Not listed: {full.skippedEmpty.map(nameOf).join(', ')} — no pre-assessment questions yet, so there is nothing to copy from{full.skippedEmpty.length === 1 ? ' it' : ' them'}.

)} {/* COLLISION — asked only when it actually applies. */} {plan.collidingModules.length > 0 ? (
{plan.collidingModules.length === 1 ? 'One module' : `${plan.collidingModules.length} modules`} {' '}already {plan.collidingModules.length === 1 ? 'has' : 'have'} post-assessment questions
) : (

None of the selected modules has post-assessment questions yet, so nothing will be overwritten.

)} {/* A copy into a switched-off assessment shows a learner nothing. */} {plan.postDisabled && ( )}
{selection.length === 0 ? 'Pick at least one module.' : `Copying ${plan.totalCopying} question${plan.totalCopying === 1 ? '' : 's'} into ` + `${plan.rows.length} module${plan.rows.length === 1 ? '' : 's'}.`}
, document.body )}
); } // ── AI question generation ─────────────────────────────────────────────────── // // Omar, 2026-08-10: "there has to be an Ai button that generate the questions, // answer and feedback dynamically based on the text on the content. It needs to // ask also how many quetions per module it is required to generate." And on what // happens to existing questions: "either generate the questions for all modules, // replacing what currently exist, or add specific question to specific modules". // // So the SCOPE decides the collision behaviour, and the dropdown says so in each // option's own label rather than hiding it in a tooltip: // All modules → REPLACES what is there // One named module → ADDS to what is there // // Panel layout follows the design locked on 2026-06-02 (§2 Q2): a Generate button, // a scope dropdown, and a questions-per-module input defaulting to 3, min 1, max 10. // // Everything the model returns is filtered by the route against the four-answer // shape before it gets here, and filtered AGAIN by `validateGeneratedQuestion` // before it is merged — because `PUT /draft` is all-or-nothing, so one malformed // question would 400 the author's entire course. function AssessmentGeneratePanel({ which, course, modules, layoutDrafts, defaultLang, onApply }) { const [scope, setScope] = React.useState('__all'); const [count, setCount] = React.useState(3); const [busy, setBusy] = React.useState(null); // null | 'M1' | 'all' const [progress, setProgress] = React.useState(''); const [result, setResult] = React.useState(null); // {added, rejected[], notes[], skipped[]} const [error, setError] = React.useState(null); const lang = defaultLang || 'en'; const targets = scope === '__all' ? modules : modules.filter(m => m.id === scope); const mode = scope === '__all' ? 'replace' : 'add'; const run = async () => { setError(null); setResult(null); setBusy(scope === '__all' ? 'all' : scope); const base = (window.DYNAMO_ENV && window.DYNAMO_ENV.gatewayBase) || ''; let token; try { token = await window.dynamoGetAccessToken(); } catch (e) { setBusy(null); setError('Could not get an access token from the signed-in session. Try signing out and back in.'); return; } const perModule = []; const rejected = []; const notes = []; const skipped = []; for (let i = 0; i < targets.length; i++) { const m = targets[i]; setProgress(`${m.id} — ${i + 1} of ${targets.length}`); const text = window.moduleTextFor(m, layoutDrafts, lang); let res; try { res = await fetch(`${base}/v1/generate-questions`, { method: 'POST', headers: { 'Content-Type': 'application/json', Authorization: `Bearer ${token}` }, body: JSON.stringify({ language: lang, count: Number(count) || 3, moduleTitle: (m.title && m.title[lang]) || '', moduleText: text, }), }); } catch (e) { setBusy(null); setProgress(''); setError('Could not reach the server. Check your connection and try again.'); return; } const body = await res.json().catch(() => ({})); if (!res.ok) { // A per-module failure must not abandon the modules already done, and the // reason has to survive to the summary — "generation failed" with no cause // is the message an author can do nothing with. skipped.push(`${m.id}: ${body.message || `HTTP ${res.status}`}`); continue; } // Second gate, on our side of the wire. The route already filtered; this // catches anything that would still fail the schema, because one bad // question 400s the whole draft. const good = (body.questions || []).filter( q => window.validateGeneratedQuestion(q, lang).length === 0); const lost = (body.questions || []).length - good.length; if (lost > 0) rejected.push(`${m.id}: ${lost} discarded before saving`); (body.rejected || []).forEach(r => rejected.push(`${m.id}: ${r}`)); if (body.note) notes.push(`${m.id}: ${body.note}`); if (good.length) perModule.push({ moduleId: m.id, questions: good }); else if (!body.message) skipped.push(`${m.id}: nothing usable came back`); } setBusy(null); setProgress(''); if (perModule.length) onApply(perModule, mode); setResult({ added: perModule.reduce((n, x) => n + x.questions.length, 0), modules: perModule.length, rejected, notes, skipped, mode, }); }; return (
Generate questions with AI
Written from each module's own content, in {lang.toUpperCase()} — translate afterwards from Localisation.
{error && (
{error}
)} {result && (
{result.added === 0 ? 'No questions were added.' : `${result.added} question${result.added === 1 ? '' : 's'} ` + `${result.mode === 'replace' ? 'replaced what was in' : 'added to'} ` + `${result.modules} module${result.modules === 1 ? '' : 's'}.`} {result.added > 0 && ' Read them before you build — they are a first draft.'}
{/* Every shortfall is NAMED. A short batch reported as plain success is how an author comes to believe the module only had two ideas in it. */} {result.skipped.map((s, i) => (
⚠ {s}
))} {result.notes.map((n, i) => (
{n}
))} {result.rejected.length > 0 && (
{result.rejected.length} returned question {result.rejected.length === 1 ? '' : 's'} did not fit the required four-answer shape and {result.rejected.length === 1 ? 'was' : 'were'} discarded.
)}
Needs translating into your other languages — Localisation ▸ Assessment.
)}
); }