@intellectif/lk-react 14.0.0 → 14.1.0

package/dist/chunk-D57QZILZ.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/components/shared/capture-registry.ts","../src/components/shared/sequence-slot.ts","../src/components/ReadAloud/ReadAloud.tsx","../src/components/ReadAloud/index.tsx"],"names":["takes","take","state","ReadAloud","jsx"],"mappings":"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","file":"chunk-D57QZILZ.js","sourcesContent":["'use client';\n\n/**\n * Microphone captures that must stop when the region holding them goes away,\n * keyed by group name.\n *\n * Module-level for the reason `playback-group.ts` is: the thing that knows a\n * pane was hidden — the sequence — is not the thing holding the microphone,\n * and a context would have to be threaded through every activity component to\n * reach one. The caller mints the group name per region; a sequence uses the\n * slot's, so hiding one slot stops that slot's capture and no other's. The name\n * reaches a recorder only through `SequenceSlotContext`, never as a prop, so no\n * consumer string can join another region's group.\n *\n * This **supplements** a recorder's own teardown and never replaces it. The\n * sequence's pane effect runs only on a `hidden` transition, not on unmount,\n * and neither a preview nor a standalone render has panes at all — so a\n * component that records still releases the microphone from its own cleanup,\n * and this registry only covers the case where the component is left mounted\n * and merely hidden.\n *\n * No `useCaptureGroup` hook, unlike playback: that one re-registers after every\n * commit because the element behind a ref can be replaced while the ref object\n * is not, whereas a recorder's `stop` keeps one identity for the life of the\n * hook and a plain effect registers it exactly once.\n */\nconst groups = new Map<string, Set<() => void>>();\n\n/** Adds a capture's stop to a group; returns the matching removal. */\nexport function joinCaptureGroup(group: string, stop: () => void): () => void {\n  let members = groups.get(group);\n  if (members === undefined) {\n    members = new Set();\n    groups.set(group, members);\n  }\n  members.add(stop);\n  return () => {\n    const current = groups.get(group);\n    if (current === undefined) {\n      return;\n    }\n    current.delete(stop);\n    if (current.size === 0) {\n      groups.delete(group);\n    }\n  };\n}\n\n/**\n * Stops every capture in the group.\n *\n * The members are copied before they are called. Each `stop` is expected to\n * run its own removal, and a component that answers one by starting again\n * would otherwise be stopped by the sweep that its own stop provoked.\n */\nexport function stopCaptureGroup(group: string): void {\n  const members = groups.get(group);\n  if (members === undefined) {\n    return;\n  }\n  for (const stop of [...members]) {\n    stop();\n  }\n}\n","'use client';\n\nimport { createContext } from 'react';\n\n/**\n * How far a take that was handed in has got, as a pager deciding whether its\n * set is finished needs to know it.\n *\n * - `in-flight` — being stored or being judged. The set waits for it.\n * - `retryable` — it failed, and the learner is being offered another try at\n *   the SAME take. The set waits for it while the learner is on that question.\n * - `settled` — nothing more will come of it: a grade, a take with no grade, a\n *   failure nobody can retry, or a take the learner walked away from.\n */\nexport type TakeState = 'in-flight' | 'retryable' | 'settled';\n\n/**\n * What a pager hands the one slot it renders, and only through\n * {@link SequenceSlotContext} — never as a prop, so none of it can appear on a\n * public component's signature. A consumer string in any of it could stop\n * another component's microphone or finish another paper's set.\n */\nexport interface SequenceSlotChannel {\n  /**\n   * The capture-registry group whose captures stop when the slot's pane is\n   * hidden. Minted per pager and per slot, so no two pagers share one.\n   */\n  readonly captureGroup: string;\n  /**\n   * Reports the state of the take numbered `take`, a number from\n   * {@link mintTake}. A take numbered below the slot's latest is a take the\n   * learner has since replaced, and the pager ignores it.\n   */\n  takeState(take: number, state: TakeState): void;\n}\n\n/** `null` outside a pager: a standalone component belongs to no slot. */\nexport const SequenceSlotContext = createContext<SequenceSlotChannel | null>(null);\n\n/**\n * The last take number handed out. Module-level and never reset, so a number\n * is unique for the life of the page: across mounts, across papers, and across\n * two pagers side by side. A result can therefore only ever match the take that\n * produced it, whatever slot and activity ids a later paper reuses — ids a host\n * chooses, and can repeat, never decide it.\n */\nlet lastTake = 0;\n\n/** A take number no other take on this page has had, or will have. */\nexport function mintTake(): number {\n  lastTake += 1;\n  return lastTake;\n}\n\n/**\n * The take each reported value belongs to. A `WeakMap` rather than a field, so\n * a response or a result a host receives carries no extra key it would persist\n * or compare, and the number never outlives the object.\n */\nconst takes = new WeakMap<object, number>();\n\n/** Marks `value` as produced by take `take`, and returns it. */\nexport function stampTake<T extends object>(value: T, take: number): T {\n  takes.set(value, take);\n  return value;\n}\n\n/** The take `value` was produced by, or `undefined` when nothing stamped it. */\nexport function takeOf(value: unknown): number | undefined {\n  return typeof value === 'object' && value !== null ? takes.get(value) : undefined;\n}\n","'use client';\n\nimport {\n  type ActivityMedia as ActivityMediaData,\n  ActivitySchemaError,\n  assertRedacted,\n  type GradeRecord,\n  type InteractionKind,\n  type LearnerResponse,\n  type MediaPlaybackPolicy,\n  READ_ALOUD_MAX_SECONDS,\n  READ_ALOUD_MAX_TAKES,\n  type ReadAloudData,\n  type ReadAloudLearnerResponse,\n  type ReadAloudWordAlignment,\n  type RecordingRef,\n  type ScoringDetail,\n  type SpeechAssessment,\n  validateActivity,\n  xAPIBuilder,\n  xapiDefinitionFor,\n} from '@intellectif/lk-core';\nimport {\n  type CSSProperties,\n  useCallback,\n  useContext,\n  useEffect,\n  useId,\n  useMemo,\n  useRef,\n  useState,\n} from 'react';\nimport { useActivityState } from '../../hooks/useActivityState.js';\nimport type { RecordedTake, SpeechRecorderStatus } from '../../hooks/useSpeechRecorder.js';\nimport { useSpeechRecorder } from '../../hooks/useSpeechRecorder.js';\nimport { localeDirectionOf } from '../../i18n/direction.js';\nimport { useLkStrings } from '../../i18n/LkIntlProvider.js';\nimport type { LkStrings } from '../../i18n/strings.js';\nimport { ANONYMOUS_ACTOR, isDevelopment, objectIdFor } from '../_internal.js';\nimport { PronunciationFeedback } from '../PronunciationFeedback/index.js';\nimport { markSentence, VISUALLY_HIDDEN } from '../PronunciationFeedback/PronunciationFeedback.js';\nimport { ActivityMedia } from '../shared/ActivityMedia.js';\nimport { joinCaptureGroup } from '../shared/capture-registry.js';\nimport { FeedbackRegion } from '../shared/FeedbackRegion.js';\nimport {\n  fractionOfGrade,\n  type OutcomeReading,\n  percentOfGrade,\n  type ReadGrade,\n  readAssessResult,\n  readEvidence,\n  readOutcome,\n} from '../shared/read-grade.js';\nimport {\n  mintTake,\n  SequenceSlotContext,\n  stampTake,\n  type TakeState,\n} from '../shared/sequence-slot.js';\nimport type { ActivityProps, Renderable } from '../types.js';\n\n/**\n * Names playback groups for the model recordings. Per mount and never derived\n * from `useId`: two separately hydrated roots derive the same id for the same\n * tree position, and their recordings would pause each other. The name never\n * reaches the DOM.\n */\nlet modelsGroupCount = 0;\n\n/** A title with something in it a screen reader can say. */\nconst VISIBLE_TEXT_RE = /[^\\p{White_Space}\\p{Cc}\\p{Cf}\\p{Default_Ignorable_Code_Point}]/u;\n\n/** A stored mark's id, as `gradeReadAloud` numbers the reference words. */\nconst MARK_ID_RE = /^w\\d+$/;\n\n/** The states a mark rebuilt from stored details can carry: insertions are not stored. */\nconst STORED_STATES: readonly ReadAloudWordAlignment['state'][] = [\n  'correct',\n  'mispronounced',\n  'omitted',\n];\n\n/** The level meter's resolution, in steps the skin can select on. */\nconst LEVEL_STEPS = 10;\n\n/**\n * What an application's assessor came back with.\n *\n * `code` is a plain `string` and not `SpeechUnscorableCode`: an application's\n * own assessor may refuse a take for a reason the SDK has no name for, and a\n * narrower type would make it unreportable. This component classifies the two\n * codes that mean \"nothing was heard\" and treats every other one the same way.\n */\nexport type ReadAloudAssessResult =\n  | { status: 'graded'; assessment: SpeechAssessment; grade: GradeRecord }\n  | { status: 'unscorable'; code: string; assessment?: SpeechAssessment }\n  | { status: 'failed'; retryable: boolean };\n\n/**\n * How a take reaches the application, and how a judgement comes back.\n *\n * Named `recordingBinding` rather than `recording` because both\n * `ReadAloudData.recording` (the bounds) and `ReadAloudLearnerResponse.recording`\n * (the stored take) already exist: the plain name would read as one of those.\n */\nexport interface RecordingBinding {\n  /**\n   * Puts the take in your storage and returns its key. **Required** outside\n   * `review`: without it a learner can speak into a control that submits\n   * nothing. Settle it — a promise that never does leaves the submit pending\n   * for ever.\n   */\n  upload(take: RecordedTake): Promise<RecordingRef>;\n  /**\n   * Judges the stored take. `practice` only — an exam never assesses on the\n   * client. Optional: a binding without it records, uploads and submits, and\n   * the feedback is replaced by a notice.\n   */\n  assess?(ref: RecordingRef): Promise<ReadAloudAssessResult>;\n  /** A playable link to a stored take. `review` only. */\n  playbackUrl?(ref: RecordingRef): Promise<string>;\n}\n\nexport interface ReadAloudProps extends ActivityProps<ReadAloudData> {\n  /** How a take is stored and judged. See {@link RecordingBinding}. */\n  recordingBinding?: RecordingBinding;\n  /**\n   * The evidence behind a stored grade, for `review`. Without it a graded\n   * outcome still shows its marks, rebuilt from `outcome.grade.details`; with\n   * neither, the score is shown and no marks are.\n   */\n  assessment?: SpeechAssessment;\n  /**\n   * Confidence above which a break note is shown, 0..1, forwarded to\n   * {@link PronunciationFeedback}. No default — see its own prop.\n   */\n  breakThreshold?: number;\n  /** The same, for the monotone note. */\n  monotoneThreshold?: number;\n  /**\n   * Never called. A read-aloud answer is a key in your storage, and there is\n   * none until the take has been uploaded — so there is no intermediate\n   * response to report, and reporting the take itself would offer a host a\n   * recording it has nowhere to put. `onSubmit` carries the response, once.\n   */\n  onChange?: (response: LearnerResponse) => void;\n}\n\n/** What the live region says: the SDK's own sentence, then any grader feedback. */\ninterface Announcement {\n  text: string;\n  feedback: string | null;\n}\n\n/**\n * How far the submitted take has got. `idle` also means \"nothing submitted yet\".\n *\n * Every other phase names its `take`, the number `mintTake` gave the submit\n * that reached it: a phase describes one take, and a pager told about it must\n * be able to tell that take from the one before it.\n */\ntype SubmitPhase =\n  | { kind: 'idle' }\n  | { kind: 'uploading'; take: number }\n  | { kind: 'upload-failed'; take: number }\n  | { kind: 'assessing'; take: number }\n  | { kind: 'submitted'; take: number }\n  | { kind: 'unassessed'; take: number }\n  /**\n   * The assessor's judgement, as `readAssessResult` read it: `grade` is `null`\n   * when what came back cannot be shown as a grade, and `assessment` is `null`\n   * when there is no evidence to mark words from.\n   */\n  | {\n      kind: 'graded';\n      take: number;\n      assessment: SpeechAssessment | null;\n      grade: ReadGrade | null;\n    }\n  | { kind: 'unscorable'; take: number; code: string | undefined }\n  | { kind: 'assess-failed'; take: number; retryable: boolean };\n\n/**\n * Whether the screen offers \"Try again\" for the take this phase describes —\n * the one answer to that question, read by the button that offers it and by\n * the take state a pager is told, so the two cannot disagree. A retry re-sends\n * the SAME take: a take that failed to upload is sent again, and a stored take\n * whose assessment failed is judged again without being uploaded twice.\n */\nfunction offersRetry(phase: SubmitPhase, uploaded: RecordingRef | null): boolean {\n  return (\n    phase.kind === 'upload-failed' ||\n    (phase.kind === 'assess-failed' && phase.retryable && uploaded !== null)\n  );\n}\n\n/**\n * The state of the phase's take, as a pager deciding whether its set is\n * finished reads it. Derived from the phase alone, so no path through a submit\n * can leave a pager waiting on a take this component has finished with: every\n * path ends in a phase.\n */\nfunction takeStateOf(phase: SubmitPhase, uploaded: RecordingRef | null): TakeState {\n  if (phase.kind === 'uploading' || phase.kind === 'assessing') {\n    return 'in-flight';\n  }\n  return offersRetry(phase, uploaded) ? 'retryable' : 'settled';\n}\n\n/**\n * What a take is a take OF: the item, the words, their language and the bounds\n * the take is captured under. A change to any of these is a different reading,\n * and a take of the old one answers nothing.\n *\n * Deliberately NOT the identity of `data`. `redact()` returns a new object on\n * every call, and `activities={raw.map(redact)}` is a documented way to pass a\n * paper, so a host that rebuilds its items on every render is ordinary — and a\n * reset keyed on identity silently threw away every grade still in flight and\n * refunded the take budget on each of those renders, so a `maxTakes: 1` exam\n * accepted a second take. The title, the instructions and the model recordings\n * are presentation; editing them leaves the take a take of the same reading.\n *\n * The bounds are the CLAMPED ones, which are what the recorder is given. Read\n * field by field into strings, so no value unvalidated data carries can make\n * the key throw.\n */\nfunction readingKeyOf(\n  data: Renderable<ReadAloudData>,\n  bounds: { maxSeconds: number; minSeconds: number | undefined; maxTakes: number | undefined },\n): string {\n  const text = (value: unknown): string | null => (typeof value === 'string' ? value : null);\n  return JSON.stringify([\n    text(data.id),\n    text(data.referenceText),\n    text(data.locale),\n    String(bounds.maxSeconds),\n    String(bounds.minSeconds),\n    String(bounds.maxTakes),\n  ]);\n}\n\n/**\n * The slower model recording as an `ActivityMedia`: it follows the model\n * recording's playback policy minus `maxPlays` (`controls`, `seek`, `rate`,\n * the native hints), so a locked scrubber or a fixed speed binds both files —\n * and it never carries a budget of its own, so `<ActivityMedia>` never demands\n * a binding for it. `undefined` when there is no slow recording.\n */\nfunction slowMediaFor(\n  data: Renderable<ReadAloudData>,\n  label: string,\n): ActivityMediaData | undefined {\n  const slow = data.slowMedia;\n  if (slow === undefined) {\n    return undefined;\n  }\n  const policy: MediaPlaybackPolicy = data.media?.playback ?? {};\n  const { maxPlays: _budget, ...inherited } = policy;\n  const hasPolicy = Object.values(inherited).some((value) => value !== undefined);\n  return {\n    type: 'audio',\n    url: slow.url,\n    alt: slow.alt ?? label,\n    ...(hasPolicy ? { playback: inherited } : {}),\n  };\n}\n\n/**\n * Word marks rebuilt from stored scoring details — a server-recorded mark shown\n * after the fact, with no assessment on the client. Inserted words are not in\n * the details (`gradeReadAloud` stores one mark per REFERENCE word, and a word\n * the learner added is not one the item asked for), so none appear.\n *\n * The details are a read grade's, so every entry is well-formed; what is left\n * to decide here is whether they are word marks at all, rather than a rubric's\n * own breakdown.\n */\nfunction marksFromDetails(details: readonly ScoringDetail[]): ReadAloudWordAlignment[] | null {\n  if (details.length === 0 || !details.every((detail) => MARK_ID_RE.test(detail.itemId))) {\n    return null;\n  }\n  return details.map((detail) => {\n    const heard = Array.isArray(detail.learnerResponse)\n      ? detail.learnerResponse.join(' ')\n      : detail.learnerResponse;\n    const reference = Array.isArray(detail.correctResponse)\n      ? detail.correctResponse.join(' ')\n      : detail.correctResponse;\n    const correct = detail.outcome !== undefined ? detail.outcome === 'correct' : detail.correct;\n    const state: ReadAloudWordAlignment['state'] = correct\n      ? 'correct'\n      : detail.outcome === 'incorrect-omission'\n        ? 'omitted'\n        : 'mispronounced';\n    return {\n      itemId: detail.itemId,\n      reference,\n      heard,\n      state,\n      // `ScoringDetail.score` is the word's accuracy divided by 100; the marks\n      // carry it back in the units the assessment used.\n      ...(typeof detail.score === 'number' ? { accuracy: detail.score * 100 } : {}),\n    };\n  });\n}\n\n/** The stored take a learner response points at, or `null` for a blank or another type. */\nfunction recordingOf(response: LearnerResponse | undefined): RecordingRef | null {\n  return response !== undefined && response.type === 'read-aloud' ? response.recording : null;\n}\n\n/** The response this component emits; `takes` is written only when one was made. */\nfunction responseOf(recording: RecordingRef | null, takes: number): ReadAloudLearnerResponse {\n  return { type: 'read-aloud', recording, ...(takes > 0 ? { takes } : {}) };\n}\n\n/**\n * Which learner message an unscorable code earns. The two codes that mean\n * \"nothing was heard\" send the learner back to a quieter room; every other one,\n * the SDK's and an application's own alike — and no code at all — says only\n * that this take could not be assessed. **The code itself is never shown** — it\n * is a developer's label.\n */\nfunction unscorableMessage(code: string | undefined, s: LkStrings): string {\n  return code === 'no_speech' || code === 'insufficient_voiced_time'\n    ? s.readAloudNotHeard\n    : s.readAloudNotAssessed;\n}\n\n/**\n * The announcement, with grader feedback in its own isolated span: its\n * direction is its own, so an English \"Well read.\" in an Arabic interface keeps\n * its full stop at its end. Its language is not guessed — feedback may be\n * written in the interface's language or the reading's.\n */\nfunction AnnouncementText({ announcement }: { announcement: Announcement | null }) {\n  if (announcement === null) {\n    return null;\n  }\n  return (\n    <>\n      {announcement.text}\n      {announcement.feedback ? (\n        <>\n          {' '}\n          <span dir=\"auto\">{announcement.feedback}</span>\n        </>\n      ) : null}\n    </>\n  );\n}\n\n/**\n * The server's outcome in `review`, as `readOutcome` read it. Nothing on this\n * path scores, infers or defaults a grade.\n *\n * `scoreShown` says whether the grade is already on screen — it is, whenever\n * `<PronunciationFeedback>` was given the same grade — so the sentence is not\n * rendered twice. The wrapper and its attributes are rendered either way,\n * because they are what a stylesheet and a diagnostic read.\n */\nfunction OutcomeSummary({\n  reading,\n  s,\n  scoreShown,\n}: {\n  reading: OutcomeReading;\n  s: LkStrings;\n  scoreShown: boolean;\n}) {\n  switch (reading.kind) {\n    case 'graded':\n      return (\n        <div\n          className=\"lk-ra-outcome\"\n          data-status={reading.status}\n          data-passed={String(reading.grade.passed)}\n        >\n          {scoreShown ? null : (\n            <>\n              <p className=\"lk-ra-grade\">\n                {s.scoreAnnouncement(percentOfGrade(reading.grade), reading.grade.passed)}\n              </p>\n              {reading.grade.feedback ? (\n                <p className=\"lk-ra-grade-feedback\" dir=\"auto\">\n                  {reading.grade.feedback}\n                </p>\n              ) : null}\n            </>\n          )}\n        </div>\n      );\n    case 'deferred':\n      return (\n        <div className=\"lk-ra-outcome\" data-status=\"deferred\">\n          <p className=\"lk-ra-grade\">{s.awaitingGrade}</p>\n        </div>\n      );\n    case 'unscorable':\n      // An unscorable code is a developer-facing label: it goes on the element\n      // for diagnostics and routing, and never in front of the learner as text.\n      return (\n        <div\n          className=\"lk-ra-outcome\"\n          data-status=\"unscorable\"\n          {...(reading.code !== undefined ? { 'data-code': reading.code } : {})}\n        >\n          <p className=\"lk-ra-grade\">{s.couldNotBeGraded}</p>\n        </div>\n      );\n    default:\n      // A stored outcome that claims a grade and carries none that can be read\n      // gets the deferred vocabulary's own sentence rather than \"Score NaN%.\":\n      // there is a grade, and this screen cannot say what it was. No\n      // `data-passed`, because there is no verdict to style.\n      return (\n        <div\n          className=\"lk-ra-outcome\"\n          {...(reading.status !== undefined ? { 'data-status': reading.status } : {})}\n        >\n          <p className=\"lk-ra-grade\">{s.couldNotBeGraded}</p>\n        </div>\n      );\n  }\n}\n\n/**\n * Reads a text aloud and hands the recording to the application.\n *\n * The SDK records; it never judges. A take is captured as mono 16-bit PCM WAV\n * at 16 kHz — the one format `inspectWav` measures directly — handed to\n * `recordingBinding.upload`, and reported through `onSubmit`. Whether anything\n * assesses it, and where, is the application's: in `practice` an optional\n * `assess` may come back with a grade, and in `exam` nothing is ever assessed\n * on the client.\n *\n * **`recordingBinding.upload` is required outside `review`** and its absence\n * throws at render, in production too: a learner must never speak into a\n * control that stores nothing. `assess` is not required — a binding without it\n * records, uploads and submits, and shows a notice in place of the feedback.\n *\n * **A grade that comes back is read, not trusted** — whether `assess` returned\n * it or `outcome` carries it. A score that is not a number between 0 and its\n * maximum, or a `passed` that is not a boolean, is shown as could-not-be-graded\n * and never reaches `onComplete` or a statement; `onComplete` fires exactly when\n * a score is on screen, with that score.\n *\n * ```tsx\n * <ReadAloud\n *   data={item}\n *   recordingBinding={{ upload, assess }}\n *   onSubmit={persist}\n *   onComplete={record}\n * />\n * ```\n */\nexport function ReadAloud({\n  data,\n  onComplete,\n  onSubmit,\n  onInteraction,\n  value,\n  defaultValue,\n  defaultSubmitted,\n  renderMode = 'practice',\n  outcome,\n  mediaBudget,\n  mediaStrings,\n  strings,\n  theme,\n  locale,\n  disabled,\n  recordingBinding,\n  assessment,\n  breakThreshold,\n  monotoneThreshold,\n}: ReadAloudProps) {\n  const isExam = renderMode === 'exam';\n  const isReview = renderMode === 'review';\n  const s = useLkStrings(strings);\n  // The pager slot this component sits in, if any: the capture group its pane\n  // stops, and where the state of each take is reported. A context and never a\n  // prop, so none of it is on this component's published signature — a\n  // consumer string in a prop could stop another pager's microphone. `null`\n  // for a standalone component, which then belongs to no group at all and\n  // releases the microphone from its own unmount alone.\n  const slot = useContext(SequenceSlotContext);\n  const captureGroup = slot?.captureGroup;\n\n  const devError = useMemo(() => {\n    if (!isDevelopment()) {\n      return null;\n    }\n    // No `hasKey` branch, unlike `<Dictation>`: a read-aloud item has no answer\n    // key, so `redact()` produces a projection the strict redacted schema\n    // describes exactly and there is no revealed variant to make room for.\n    if (data.redacted === true) {\n      try {\n        assertRedacted(data);\n        return null;\n      } catch (error) {\n        return error instanceof Error ? error : new Error(String(error));\n      }\n    }\n    const result = validateActivity('read-aloud', data);\n    return result.success ? null : new ActivitySchemaError('read-aloud', result.errors);\n  }, [data]);\n\n  // The bounds a take is captured under, CLAMPED and not merely defaulted,\n  // because `practice` renders unvalidated content in production: a\n  // `maxSeconds` that is not a number would make the auto-stop comparison NaN,\n  // and a `maxSeconds` of 100000 passes every guard a NaN check makes and arms\n  // a recording that never stops itself — the one failure a learner cannot see\n  // coming, and one that fills the tab's memory while it happens. The schema's\n  // own ceilings are the bounds, so unvalidated data can only ever be stricter\n  // than the ceiling, never looser.\n  const bounds = data.recording as Partial<ReadAloudData['recording']> | undefined;\n  const maxSeconds =\n    typeof bounds?.maxSeconds === 'number' && bounds.maxSeconds > 0\n      ? Math.min(bounds.maxSeconds, READ_ALOUD_MAX_SECONDS)\n      : READ_ALOUD_MAX_SECONDS;\n  const minSeconds = typeof bounds?.minSeconds === 'number' ? bounds.minSeconds : undefined;\n  // A take count that is not a whole number in range would put \"NaN of NaN\n  // recordings left\" in front of the learner and leave `canRecord` false for\n  // ever, which reads as a recorder that is simply broken.\n  const maxTakes =\n    typeof bounds?.maxTakes === 'number' && Number.isFinite(bounds.maxTakes)\n      ? Math.min(Math.max(1, Math.floor(bounds.maxTakes)), READ_ALOUD_MAX_TAKES)\n      : undefined;\n  const readingKey = readingKeyOf(data, { maxSeconds, minSeconds, maxTakes });\n\n  const recorder = useSpeechRecorder(\n    useMemo(\n      () => ({\n        maxDurationMs: maxSeconds * 1000,\n        ...(minSeconds !== undefined ? { minDurationMs: minSeconds * 1000 } : {}),\n        ...(maxTakes !== undefined ? { maxTakes } : {}),\n      }),\n      [maxSeconds, minSeconds, maxTakes],\n    ),\n  );\n\n  const { state, start, complete, getTimeSpent, reset } = useActivityState(\n    defaultSubmitted === true ? 'completed' : 'idle',\n  );\n  const [phase, setPhase] = useState<SubmitPhase>({ kind: 'idle' });\n  const [uploaded, setUploaded] = useState<RecordingRef | null>(null);\n  const [takeUrl, setTakeUrl] = useState<string | null>(null);\n  const [playbackUrl, setPlaybackUrl] = useState<string | null>(null);\n  // Re-keys the alert so the SAME message announces again — a learner who is\n  // refused the microphone twice hears it twice.\n  const [errorNonce, setErrorNonce] = useState(0);\n\n  const ids = useId();\n  const titleId = `${ids}-title`;\n  // Per mount, not per activity id: two renderings of one item on a page (a\n  // review list, a preview beside a sequence) are separate players.\n  const [modelsGroup] = useState(() => {\n    modelsGroupCount += 1;\n    return `lk-ra-models-${modelsGroupCount}`;\n  });\n\n  // The latest callbacks, so an effect can fire an event without depending on a\n  // binding or a handler the host rebuilds on every render.\n  const interactionRef = useRef(onInteraction);\n  interactionRef.current = onInteraction;\n  const bindingRef = useRef(recordingBinding);\n  bindingRef.current = recordingBinding;\n  // Guards a second submit while one is in flight: two clicks would upload the\n  // same take twice and charge the application for two assessments.\n  const submittingRef = useRef(false);\n  // Which reading this instance is on. Everything asynchronous reads it once\n  // and re-reads it after every await, so an instance that has been unmounted,\n  // or handed a different reading, reports nothing for the one it has left —\n  // the treatment the playback-url effect below already gives itself.\n  //\n  // A counter rather than the boolean `live` that effect uses, because a\n  // boolean cleared on the reading reset would stay cleared and leave a\n  // perfectly live component unable to submit its next take.\n  const runRef = useRef(0);\n  // The pager slot as of the latest render, and the last take it was told\n  // about, so an unmount can tell it that take is over — a take whose result\n  // this instance will now never report must not hold a set open for ever.\n  const slotRef = useRef(slot);\n  slotRef.current = slot;\n  const reportedTakeRef = useRef<number | null>(null);\n  useEffect(\n    () => () => {\n      runRef.current += 1;\n      const take = reportedTakeRef.current;\n      if (take !== null) {\n        slotRef.current?.takeState(take, 'settled');\n      }\n    },\n    [],\n  );\n\n  const fire = useCallback(\n    (type: InteractionKind, payload: Record<string, unknown>): void => {\n      interactionRef.current?.({ type, activityId: data.id, timestamp: Date.now(), payload });\n    },\n    [data.id],\n  );\n\n  // `recording-started` and `recording-stopped` are reported from the recorder's\n  // own status rather than from the click handlers: a take also ends when it\n  // reaches its bound, and a handler would report only the ends a learner asked\n  // for.\n  const lastStatusRef = useRef<SpeechRecorderStatus>(recorder.status);\n  useEffect(() => {\n    if (lastStatusRef.current === recorder.status) {\n      return;\n    }\n    lastStatusRef.current = recorder.status;\n    if (recorder.status === 'recording') {\n      fire('recording-started', { takes: recorder.takesUsed, durationMs: 0 });\n    } else if (recorder.status === 'recorded' && recorder.take !== null) {\n      fire('recording-stopped', {\n        takes: recorder.takesUsed,\n        durationMs: recorder.take.durationMs,\n      });\n    }\n  }, [recorder.status, recorder.take, recorder.takesUsed, fire]);\n\n  useEffect(() => {\n    if (recorder.error !== null) {\n      setErrorNonce((nonce) => nonce + 1);\n    }\n  }, [recorder.error]);\n\n  // The take preview. Guarded because an embedder may forbid object URLs, and a\n  // preview is worth less than the take it previews.\n  const take = recorder.take;\n  useEffect(() => {\n    if (take === null || typeof URL.createObjectURL !== 'function') {\n      return;\n    }\n    const url = URL.createObjectURL(take.blob);\n    setTakeUrl(url);\n    return () => {\n      URL.revokeObjectURL(url);\n      setTakeUrl(null);\n    };\n  }, [take]);\n\n  const restored = recordingOf(value ?? defaultValue);\n  const restoredKey = restored?.key ?? null;\n  // Keyed by the reading as well as the take: the reading reset below clears\n  // the link, and a link nothing mints again would leave the stored take with\n  // no player for as long as it stays on screen.\n  // biome-ignore lint/correctness/useExhaustiveDependencies: keyed by the stored take and the reading, not by the identity of a response object a host rebuilds every render\n  useEffect(() => {\n    const binding = bindingRef.current;\n    if (!isReview || restored === null || binding?.playbackUrl === undefined) {\n      return;\n    }\n    let live = true;\n    void Promise.resolve(binding.playbackUrl(restored)).then(\n      (url) => {\n        if (live) {\n          setPlaybackUrl(url);\n        }\n      },\n      () => {\n        /* a link that could not be minted; the marks still render without it */\n      },\n    );\n    return () => {\n      live = false;\n    };\n  }, [isReview, restoredKey, readingKey]);\n\n  // What the registry may do to this component, and it is narrow: release the\n  // DEVICE, and only while one is actually open.\n  //\n  // The pager stops a hidden slot's captures on EVERY hidden transition, so a\n  // join that discarded unconditionally threw away a take that was already\n  // encoded — and `discard` deliberately refunds nothing, so Next then Prev\n  // left the learner an activity they could no longer answer and no message\n  // saying why. That contradicts the pager's own founding principle: slots stay\n  // mounted precisely so nobody silently loses an answer. A capture still\n  // running has nothing to lose yet; a finished take has everything.\n  //\n  // The status is read from a ref so this callback keeps ONE identity and the\n  // effect below joins the group exactly once, as `playback-group`'s does.\n  const statusRef = useRef(recorder.status);\n  statusRef.current = recorder.status;\n  const releaseMicrophone = useCallback(() => {\n    // `requesting-permission` counts: a prompt answered after the pane went\n    // away would otherwise open a microphone nobody is in front of.\n    if (statusRef.current === 'recording' || statusRef.current === 'requesting-permission') {\n      recorder.discard();\n    }\n  }, [recorder.discard]);\n\n  // The registry SUPPLEMENTS the recorder's own unmount cleanup; it covers the\n  // one case that cleanup cannot, a component left mounted and merely hidden.\n  useEffect(() => {\n    if (captureGroup === undefined) {\n      return;\n    }\n    return joinCaptureGroup(captureGroup, releaseMicrophone);\n  }, [captureGroup, releaseMicrophone]);\n\n  // Identity-guarded so the mount run is a no-op: without it this fires after\n  // the first paint and undoes every seed it was just given.\n  const defaultSubmittedRef = useRef(defaultSubmitted);\n  useEffect(() => {\n    defaultSubmittedRef.current = defaultSubmitted;\n  }, [defaultSubmitted]);\n  // Keyed by the READING, never by the identity of `data` — see `readingKeyOf`\n  // for the regression that identity caused. A host that rebuilds an\n  // unchanged item keeps the take, the budget and any grade still in flight.\n  const lastReadingRef = useRef(readingKey);\n  useEffect(() => {\n    if (lastReadingRef.current === readingKey) {\n      return;\n    }\n    lastReadingRef.current = readingKey;\n    submittingRef.current = false;\n    // Anything still in flight belongs to the reading that has just left.\n    runRef.current += 1;\n    setPhase({ kind: 'idle' });\n    setUploaded(null);\n    setPlaybackUrl(null);\n    // `reset`, not `discard`: the takes belong to the READING, and `discard`\n    // refunds none of them on purpose. A new reading that inherited the old\n    // one's spent takes renders a recorder that looks live and refuses to\n    // record — reachable in `<ActivityPreview>`, whose remount key is derived\n    // from the media alone, so an author who tries one take and then edits the\n    // reference text can never record again without reloading the page.\n    recorder.reset();\n    reset(defaultSubmittedRef.current === true ? 'completed' : 'idle');\n  }, [readingKey, reset, recorder.reset]);\n\n  // What became of each take, told to the pager slot this sits in: the one\n  // channel through which a sequence learns whether its set can be reported.\n  //\n  // Read from the committed PHASE, and only from it. Every way a submit can end\n  // — a grade, a take with no grade, a failure, a retry, a learner recording\n  // again, a reading reset — ends in a phase, so none of them can leave a set\n  // waiting on a take this component is done with. And an effect runs after\n  // the commit, which is after `onSubmit` and `onComplete` were called for the\n  // same phase: a pager told a take has settled has already been handed\n  // everything that take produced. The one state that must not wait for a\n  // commit — a take on its way — is reported as the submit starts.\n  const phaseTake = phase.kind === 'idle' ? null : phase.take;\n  const phaseTakeState = takeStateOf(phase, uploaded);\n  useEffect(() => {\n    // An idle phase settles the take before it: re-recording drops a take\n    // whose failure was being offered a retry, and so does a reading reset.\n    const take = phaseTake ?? reportedTakeRef.current;\n    if (slot === null || take === null) {\n      return;\n    }\n    reportedTakeRef.current = take;\n    slot.takeState(take, phaseTakeState);\n  }, [slot, phaseTake, phaseTakeState]);\n\n  // Model recordings stay silent for as long as the learner records: a\n  // microphone that hears the model reading would assess the model's\n  // pronunciation, not theirs.\n  //\n  // Pausing once, when the capture starts, is not enough — the play controls\n  // are still on screen and still work throughout the take, so the hazard\n  // simply moves one door along. The listener holds the guard for the whole\n  // capture and is removed with it; `play` does not bubble, so it is taken in\n  // the capture phase.\n  const modelsRef = useRef<HTMLDivElement>(null);\n  useEffect(() => {\n    if (recorder.status !== 'recording') {\n      return;\n    }\n    const node = modelsRef.current;\n    if (node === null) {\n      return;\n    }\n    const hush = (): void => {\n      for (const media of node.querySelectorAll('audio, video')) {\n        const element = media as HTMLMediaElement;\n        if (!element.paused) {\n          element.pause();\n        }\n      }\n    };\n    hush();\n    node.addEventListener('play', hush, true);\n    return () => {\n      node.removeEventListener('play', hush, true);\n    };\n  }, [recorder.status]);\n\n  const slowMedia = useMemo(\n    () => slowMediaFor(data, s.readAloudSlowRecording),\n    [data, s.readAloudSlowRecording],\n  );\n\n  // All hooks are called before these throws, so hook order stays stable.\n  if (devError) {\n    throw devError;\n  }\n  // `review` needs no upload: it renders what a server already stored.\n  if (!isReview && recordingBinding?.upload === undefined) {\n    throw new Error(\n      `ReadAloud \"${data.id}\" was rendered in renderMode \"${renderMode}\" without ` +\n        '`recordingBinding.upload`. The learner could record a take that is stored ' +\n        'nowhere and submitted as nothing, which looks like a working activity the ' +\n        'whole way through. Pass a `recordingBinding` whose `upload` puts the take in ' +\n        'your storage and returns its key. `assess` is optional: without it the take is ' +\n        'still recorded, uploaded and submitted, and a notice replaces the feedback.',\n    );\n  }\n\n  const submitted = state === 'completed';\n  const inactive = disabled === true || submitted || isReview;\n  const busy = phase.kind === 'uploading' || phase.kind === 'assessing';\n  const takesLeft = maxTakes === undefined ? undefined : Math.max(0, maxTakes - recorder.takesUsed);\n\n  /** Marks a failure so the alert announces even when the sentence repeats. */\n  const raise = (next: SubmitPhase): void => {\n    setErrorNonce((nonce) => nonce + 1);\n    setPhase(next);\n  };\n\n  /**\n   * Tells the pager slot, if there is one, that `take` is on its way — before\n   * anything is awaited. The report a pager's set waits on must exist before\n   * the first result it waits for can arrive; the take's later states follow\n   * from the phase it reaches (see the effect above).\n   */\n  const beginTakeReport = (take: number): void => {\n    reportedTakeRef.current = take;\n    slot?.takeState(take, 'in-flight');\n  };\n\n  const runAssess = async (\n    ref: RecordingRef,\n    current: RecordedTake | null,\n    take: number,\n  ): Promise<void> => {\n    const assess = bindingRef.current?.assess;\n    const durationMs = current?.durationMs ?? 0;\n    const takes = recorder.takesUsed;\n    const run = runRef.current;\n    if (assess === undefined) {\n      // D5: a binding that stores but does not judge is a supported binding,\n      // not a mistake — it is what an authoring preview supplies.\n      setPhase({ kind: 'unassessed', take });\n      return;\n    }\n    setPhase({ kind: 'assessing', take });\n    fire('assessment-requested', { takes, durationMs });\n    let answer: unknown;\n    try {\n      answer = await assess(ref);\n    } catch {\n      // Detached while the assessor was working: an instance that has been\n      // unmounted, or handed a different reading, reports nothing for the one\n      // it has left — not a phase, not an event, and not a grade.\n      if (run !== runRef.current) {\n        return;\n      }\n      raise({ kind: 'assess-failed', take, retryable: true });\n      fire('assessment-failed', { takes, durationMs, retryable: true });\n      return;\n    }\n    if (run !== runRef.current) {\n      return;\n    }\n    // Read once, here, and nothing below touches `answer` again: the phase the\n    // screen renders from, `onComplete` and the statement all take what the\n    // reader returned, so they cannot disagree about what came back.\n    const result = readAssessResult(answer);\n    if (result.status === 'failed') {\n      raise({ kind: 'assess-failed', take, retryable: result.retryable });\n      fire('assessment-failed', { takes, durationMs, retryable: result.retryable });\n      return;\n    }\n    if (result.status === 'unscorable') {\n      // Reported as a failed assessment because that is what it is to a\n      // consumer's log — a take that produced no grade — and `code` says which\n      // kind. `retryable` is true because another take is offered.\n      setPhase({ kind: 'unscorable', take, code: result.code });\n      fire('assessment-failed', {\n        takes,\n        durationMs,\n        retryable: true,\n        ...(result.code !== undefined ? { code: result.code } : {}),\n      });\n      return;\n    }\n    const timeSpent = getTimeSpent();\n    setPhase({ kind: 'graded', take, assessment: result.assessment, grade: result.grade });\n    const grade = result.grade;\n    if (grade === null) {\n      // A judgement that carries no grade the reader can show is not an\n      // `ActivityResult`: reporting one would mean inventing the score, exactly\n      // as an `unscorable` result would. To a consumer's log it is what an\n      // unscorable take is — an assessment that produced no grade, with another\n      // take offered.\n      fire('assessment-failed', { takes, durationMs, retryable: true });\n      return;\n    }\n\n    // xAPI's `score.scaled` is a fraction in [-1, 1], and the SDK's builder\n    // writes `ScoringResult.score` into it verbatim, then validates — so a\n    // points-based grade (82 out of 100, which `GradeRecord` allows and a\n    // grader's own units readily produce) does not merely ship a wrong number:\n    // the build THROWS, and the grade never reaches the screen at all. The read\n    // grade's fraction is in 0..1 by construction, and `passed` is a boolean by\n    // construction, so the statement validates whatever the host sent. The\n    // learner's own numbers go to `onComplete` untouched.\n    //\n    // Stamped with its take, as the response was: a pager records a grade only\n    // for the take its slot holds now, so a grade that outlived a newer take\n    // can never be filed beside that newer take's response.\n    onComplete?.(\n      stampTake(\n        {\n          score: grade.score,\n          maxScore: grade.maxScore,\n          passed: grade.passed,\n          timeSpent,\n          xapiStatement: xAPIBuilder.buildAnsweredStatement({\n            actor: ANONYMOUS_ACTOR,\n            object: {\n              id: objectIdFor(data.id),\n              name: { [data.locale ?? 'en-US']: data.title },\n              ...xapiDefinitionFor(data),\n            },\n            timeSpentMs: timeSpent,\n            response: result.recognizedText ?? '',\n            // `ScoringResult.details` is required where `GradeRecord.details` is\n            // optional, and an empty list is the honest reading of \"no per-word\n            // marks were stored\" — never a mark of its own.\n            scoringResult: {\n              score: fractionOfGrade(grade),\n              maxScore: 1,\n              passed: grade.passed,\n              feedback: grade.feedback,\n              details: grade.details ?? [],\n            },\n          }),\n        },\n        take,\n      ),\n    );\n  };\n\n  const submitTake = async (current: RecordedTake | null): Promise<void> => {\n    const binding = bindingRef.current;\n    if (inactive || submittingRef.current || binding === undefined) {\n      return;\n    }\n    submittingRef.current = true;\n    const takes = recorder.takesUsed;\n    const run = runRef.current;\n    // Every submit is a take of its own, a retried upload included: a number\n    // no earlier submit on this page had, so whatever an earlier one still\n    // brings back cannot be taken for this one's.\n    const take = mintTake();\n    beginTakeReport(take);\n    try {\n      let ref: RecordingRef | null = null;\n      if (current !== null) {\n        setPhase({ kind: 'uploading', take });\n        try {\n          ref = await binding.upload(current);\n        } catch {\n          if (run !== runRef.current) {\n            return;\n          }\n          // The take never reached storage, so nothing is submitted: a take\n          // that failed to upload must not become a blank response.\n          raise({ kind: 'upload-failed', take });\n          fire('recording-upload-failed', {\n            takes,\n            durationMs: current.durationMs,\n            retryable: true,\n          });\n          return;\n        }\n        // Detached while the take travelled. The bytes are in the application's\n        // storage and this instance drops their key, which is a smaller cost\n        // than the alternative: `onSubmit` carries no activity id, so a\n        // response reported for a reading the learner has left is one a pager\n        // would file against whatever is on screen now.\n        if (run !== runRef.current) {\n          return;\n        }\n        setUploaded(ref);\n        fire('recording-uploaded', { takes, durationMs: current.durationMs });\n      }\n      onSubmit?.(stampTake(responseOf(ref, takes), take));\n      fire('submitted', { takes, durationMs: current?.durationMs ?? 0 });\n      if (isExam || ref === null) {\n        // Exam never assesses, never scores, never reveals, and builds no xAPI\n        // statement: its `correctResponsesPattern` would be the answer key, and\n        // a read-aloud is graded on a server from the stored bytes.\n        complete();\n        setPhase({ kind: 'submitted', take });\n        return;\n      }\n      await runAssess(ref, current, take);\n    } finally {\n      submittingRef.current = false;\n    }\n  };\n\n  /**\n   * Judges the take that is already stored, again — the SAME take, so the same\n   * number. Guarded like a submit: an assessment costs an application money,\n   * and two presses of one retry must not buy two of them.\n   */\n  const retryAssess = async (ref: RecordingRef, take: number): Promise<void> => {\n    if (submittingRef.current) {\n      return;\n    }\n    submittingRef.current = true;\n    beginTakeReport(take);\n    try {\n      await runAssess(ref, recorder.take, take);\n    } finally {\n      submittingRef.current = false;\n    }\n  };\n\n  const handleSubmit = (event: React.FormEvent): void => {\n    event.preventDefault();\n    if (inactive || busy || recorder.take === null || phase.kind !== 'idle') {\n      return;\n    }\n    void submitTake(recorder.take);\n  };\n\n  const beginTake = (): void => {\n    if (inactive || busy || !recorder.canRecord) {\n      return;\n    }\n    if (recorder.take !== null) {\n      fire('recording-discarded', {\n        takes: recorder.takesUsed,\n        durationMs: recorder.take.durationMs,\n      });\n    }\n    setPhase({ kind: 'idle' });\n    setUploaded(null);\n    start();\n    void recorder.start();\n  };\n\n  // The reading's own language and the direction its tag names. No `_`→`-`\n  // normalisation, unlike `<Dictation>`: `ReadAloudData.locale` is canonical by\n  // schema, so there is nothing to normalise.\n  const contentLang = typeof data.locale === 'string' ? data.locale : undefined;\n  const contentDir = localeDirectionOf(data.locale);\n\n  // What the host sent, as the one reader of a host's grade reads it. Every\n  // path below that shows or decides anything about a grade — the summary, the\n  // panel, the marks, who renders the score, the announcement — reads these and\n  // never `outcome` or `assessment` directly.\n  const outcomeReading = useMemo(() => readOutcome(outcome), [outcome]);\n  const keptEvidence = useMemo(() => readEvidence(assessment), [assessment]);\n  const storedGrade =\n    outcomeReading?.kind === 'graded' && outcomeReading.status === 'graded'\n      ? outcomeReading.grade\n      : null;\n  // The marks a review shows: the assessment when the caller kept one, and the\n  // stored details otherwise. With neither, the score is shown and no marks are.\n  const storedMarks = useMemo(\n    () =>\n      isReview && keptEvidence === null && storedGrade?.details !== undefined\n        ? marksFromDetails(storedGrade.details)\n        : null,\n    [isReview, keptEvidence, storedGrade],\n  );\n  const feedbackAssessment = isReview\n    ? keptEvidence\n    : phase.kind === 'graded'\n      ? phase.assessment\n      : null;\n  const feedbackGrade = isReview ? storedGrade : phase.kind === 'graded' ? phase.grade : null;\n  const feedbackAudio = isReview ? playbackUrl : takeUrl;\n\n  // Whether the score and the grader's words are already on screen inside the\n  // feedback panel, which is what decides who renders them here.\n  //\n  // The props say the panel WAS GIVEN a grade; only the DOM says it rendered\n  // one. The panel can fail outright — D2's dev throw for evidence the\n  // validator refuses is one way, and nothing on either path validates a host's\n  // grade either — and clipping on the props alone then hides a score that\n  // exists nowhere, leaving a learner \"this activity could not be displayed\"\n  // and no percentage at all. So the props may only ever clip for the single\n  // commit before the fact arrives, and the fact may always un-clip: a grade on\n  // screen twice is a far smaller defect than a grade nowhere. `.lk-pf-grade`\n  // is the panel's own hook for this, named as such in its source.\n  const rootRef = useRef<HTMLFormElement>(null);\n  const [panelLostTheGrade, setPanelLostTheGrade] = useState(false);\n  // Only a READ grade is handed to the panel, and the panel shows a read grade's\n  // score without exception — so the prediction is made from the reader's\n  // output, and never from a grade the panel would refuse.\n  const panelHasGrade = feedbackAssessment !== null && feedbackGrade !== null;\n  const gradeShownInPanel = panelHasGrade && !panelLostTheGrade;\n  // Deliberately without a dependency list: what it reads is the committed DOM,\n  // which no list can name. The updater keeps the settled value a fixed point,\n  // so a render that changes nothing here costs one extra pass and then stops.\n  useEffect(() => {\n    const root = rootRef.current;\n    const lost = panelHasGrade && (root === null || root.querySelector('.lk-pf-grade') === null);\n    setPanelLostTheGrade((was) => (was === lost ? was : lost));\n  });\n\n  const announcement = useMemo<Announcement | null>(() => {\n    if (isReview) {\n      return null;\n    }\n    // The two moments of a capture, said once each. The per-second counter used\n    // to be a live region of its own, so a ten-second take produced ten\n    // announcements — and on any device without headphones a screen reader\n    // speaks each of them into the take about to be assessed FOR PRONUNCIATION.\n    // This component already stops the model recordings for exactly that\n    // reason; the counter it generates itself is the same hazard.\n    if (recorder.status === 'recording') {\n      return { text: s.readAloudRecordingStarted, feedback: null };\n    }\n    // The length is in the sentence because the counter is no longer announced:\n    // a take that ran to its bound reads back as \"20 of 20 seconds\", which is\n    // how a learner hears that it stopped itself rather than that they stopped it.\n    const stopped: Announcement | null =\n      recorder.status === 'recorded' && take !== null\n        ? {\n            text: s.readAloudRecordingStopped(Math.round(take.durationMs / 1000), maxSeconds),\n            feedback: null,\n          }\n        : null;\n    if (isExam) {\n      if (phase.kind === 'submitted' || submitted) {\n        return { text: s.answerSubmitted, feedback: null };\n      }\n      return phase.kind === 'idle' ? stopped : null;\n    }\n    switch (phase.kind) {\n      case 'graded': {\n        const grade = phase.grade;\n        // A judgement with no grade that can be read says so, in the same\n        // sentence a review uses — never nothing, which reads as a grade\n        // still on its way.\n        return grade === null\n          ? { text: `${s.answerSubmitted} ${s.couldNotBeGraded}`, feedback: null }\n          : {\n              text: `${s.answerSubmitted} ${s.scoreAnnouncement(percentOfGrade(grade), grade.passed)}`,\n              feedback: grade.feedback,\n            };\n      }\n      case 'unscorable':\n        return { text: unscorableMessage(phase.code, s), feedback: null };\n      case 'unassessed':\n        return { text: s.readAloudAssessmentUnavailable, feedback: null };\n      case 'idle':\n        return stopped;\n      default:\n        // Uploading and assessing have their own pending sentence, and both\n        // failures have an alert; a stale \"recording stopped\" beside either\n        // would be the loudest thing on the screen.\n        return null;\n    }\n  }, [isReview, isExam, phase, submitted, s, recorder.status, take, maxSeconds]);\n\n  const alertText =\n    recorder.error !== null\n      ? s.readAloudRecorderError(recorder.error)\n      : phase.kind === 'upload-failed'\n        ? s.readAloudUploadFailed\n        : phase.kind === 'assess-failed'\n          ? s.readAloudAssessmentFailed\n          : null;\n\n  return (\n    <form\n      className=\"lk-ra\"\n      ref={rootRef}\n      // A title with nothing to say would name the form with silence.\n      aria-labelledby={VISIBLE_TEXT_RE.test(data.title) ? titleId : undefined}\n      lang={locale}\n      data-render-mode={renderMode}\n      style={theme as CSSProperties | undefined}\n      onSubmit={handleSubmit}\n    >\n      {/*\n        The form's name: read from here, it keeps the content's language. A\n        paragraph of its own, so without a language to go by its own first\n        letter decides its direction.\n      */}\n      <p id={titleId} className=\"lk-ra-title\" dir={contentDir ?? 'auto'} lang={contentLang}>\n        {data.title}\n      </p>\n\n      {typeof data.instructions === 'string' && data.instructions !== '' ? (\n        <p className=\"lk-ra-instructions\" dir={contentDir ?? 'auto'} lang={contentLang}>\n          {data.instructions}\n        </p>\n      ) : null}\n\n      {/* The reading itself. Never redacted: a read-aloud has no answer key, so\n          the learner's copy carries the text in full. */}\n      <p className=\"lk-ra-reference\" dir={contentDir ?? 'auto'} lang={contentLang}>\n        {data.referenceText}\n      </p>\n\n      {data.media !== undefined || slowMedia !== undefined ? (\n        <div className=\"lk-ra-models\" ref={modelsRef}>\n          {/*\n            Each model recording is a named group (a fieldset with a legend,\n            which is what `role=\"group\"` plus a label spells natively), so the\n            two players are told apart by name and not only by position.\n          */}\n          {data.media !== undefined ? (\n            <fieldset className=\"lk-ra-model\">\n              <legend className=\"lk-ra-model-label\">{s.readAloudModelRecording}</legend>\n              {/* The ONLY budgeted recording: the binding is whatever the pager or the caller passes. */}\n              <ActivityMedia\n                media={data.media}\n                renderMode={renderMode}\n                playbackGroup={modelsGroup}\n                {...(mediaBudget !== undefined ? { mediaBudget } : {})}\n                {...(mediaStrings !== undefined ? { mediaStrings } : {})}\n                {...(strings !== undefined ? { strings } : {})}\n                {...(onInteraction !== undefined ? { onInteraction } : {})}\n                {...(locale !== undefined ? { locale } : {})}\n                {...(disabled !== undefined ? { disabled } : {})}\n              />\n            </fieldset>\n          ) : null}\n          {slowMedia !== undefined ? (\n            <fieldset className=\"lk-ra-model\" data-slow=\"true\">\n              <legend className=\"lk-ra-model-label\">{s.readAloudSlowRecording}</legend>\n              {/* No budget of its own, by contract — so no binding is passed and none is demanded. */}\n              <ActivityMedia\n                media={slowMedia}\n                renderMode={renderMode}\n                playbackGroup={modelsGroup}\n                {...(mediaStrings !== undefined ? { mediaStrings } : {})}\n                {...(strings !== undefined ? { strings } : {})}\n                {...(locale !== undefined ? { locale } : {})}\n                {...(disabled !== undefined ? { disabled } : {})}\n              />\n            </fieldset>\n          ) : null}\n        </div>\n      ) : null}\n\n      {/* Gone once the item is committed, rather than left behind disabled: a\n          submitted exam answer is not a control a learner should still meet. */}\n      {isReview || submitted ? null : (\n        <div\n          className=\"lk-ra-recorder\"\n          data-status={recorder.status}\n          data-level={\n            recorder.status === 'recording'\n              ? Math.min(LEVEL_STEPS, Math.round(recorder.level * LEVEL_STEPS))\n              : undefined\n          }\n        >\n          {recorder.status === 'recording' ? (\n            <button\n              type=\"button\"\n              className=\"lk-ra-stop\"\n              disabled={inactive}\n              onClick={() => recorder.stop()}\n            >\n              {s.readAloudStop}\n            </button>\n          ) : (\n            // aria-disabled, never disabled, once the takes are spent: a\n            // natively disabled button drops keyboard focus to the page body,\n            // and this is the control a learner comes back to.\n            <button\n              type=\"button\"\n              className=\"lk-ra-record\"\n              disabled={inactive}\n              aria-disabled={!recorder.canRecord || busy || undefined}\n              onClick={beginTake}\n            >\n              {recorder.take === null ? s.readAloudRecord : s.readAloudRerecord}\n            </button>\n          )}\n          {recorder.status === 'recording' ? (\n            // Visible, and hidden from assistive technology, beside the level\n            // meter the recorder's `data-level` drives. Its text changes every\n            // whole second, so as a live region it announced ten times in a\n            // ten-second take — into the microphone. What a screen-reader\n            // learner needs instead is said once each, below.\n            <p className=\"lk-ra-progress\" aria-hidden=\"true\">\n              {s.readAloudRecordingProgress(Math.floor(recorder.elapsedMs / 1000), maxSeconds)}\n            </p>\n          ) : null}\n          {takesLeft !== undefined && maxTakes !== undefined ? (\n            <p className=\"lk-ra-takes\">{s.readAloudTakesRemaining(takesLeft, maxTakes)}</p>\n          ) : null}\n        </div>\n      )}\n\n      {!isReview && takeUrl !== null ? (\n        // biome-ignore lint/a11y/useMediaCaption: the learner's own take has no caption track to offer; its accessible name says whose recording it is\n        <audio\n          className=\"lk-ra-take\"\n          controls\n          src={takeUrl}\n          aria-label={s.readAloudYourRecording}\n          data-take={recorder.takesUsed}\n        />\n      ) : null}\n\n      {isReview && playbackUrl !== null ? (\n        // biome-ignore lint/a11y/useMediaCaption: the learner's own take has no caption track to offer; its accessible name says whose recording it is\n        <audio\n          className=\"lk-ra-take\"\n          controls\n          src={playbackUrl}\n          aria-label={s.readAloudYourRecording}\n        />\n      ) : null}\n\n      {isReview || submitted ? null : (\n        <div className=\"lk-ra-actions\">\n          <button\n            type=\"submit\"\n            className=\"lk-ra-submit\"\n            disabled={disabled === true}\n            aria-disabled={recorder.take === null || phase.kind !== 'idle' || undefined}\n            aria-busy={busy || undefined}\n          >\n            {s.submit}\n          </button>\n          {isExam ? (\n            // Explicit, and only here: an exam answer with no recording is a\n            // decision a learner takes, never something a failed upload does\n            // for them.\n            <button\n              type=\"button\"\n              className=\"lk-ra-submit-blank\"\n              disabled={inactive}\n              aria-disabled={busy || undefined}\n              onClick={() => {\n                if (!busy) {\n                  void submitTake(null);\n                }\n              }}\n            >\n              {s.readAloudSubmitWithoutRecording}\n            </button>\n          ) : null}\n          {offersRetry(phase, uploaded) ? (\n            <button\n              type=\"button\"\n              className=\"lk-ra-retry\"\n              onClick={() => {\n                if (phase.kind === 'upload-failed') {\n                  void submitTake(recorder.take);\n                } else if (phase.kind === 'assess-failed' && uploaded !== null) {\n                  void retryAssess(uploaded, phase.take);\n                }\n              }}\n            >\n              {s.readAloudTryAgain}\n            </button>\n          ) : null}\n        </div>\n      )}\n\n      {busy ? (\n        <p className=\"lk-ra-pending\" role=\"status\" aria-busy=\"true\">\n          {phase.kind === 'uploading' ? s.readAloudUploading : s.readAloudAssessing}\n        </p>\n      ) : null}\n\n      {alertText !== null ? (\n        <p key={errorNonce} className=\"lk-ra-alert\" role=\"alert\">\n          {alertText}\n        </p>\n      ) : null}\n\n      {feedbackAssessment !== null ? (\n        <PronunciationFeedback\n          data={{ referenceText: data.referenceText, locale: data.locale }}\n          assessment={feedbackAssessment}\n          {...(feedbackGrade !== null ? { grade: feedbackGrade } : {})}\n          {...(feedbackAudio !== null ? { audioUrl: feedbackAudio } : {})}\n          {...(breakThreshold !== undefined ? { breakThreshold } : {})}\n          {...(monotoneThreshold !== undefined ? { monotoneThreshold } : {})}\n          {...(locale !== undefined ? { locale } : {})}\n          {...(strings !== undefined ? { strings } : {})}\n        />\n      ) : null}\n\n      {storedMarks !== null ? (\n        <div className=\"lk-ra-marks\">\n          {/* The list's name and the hidden sentences are interface text; only\n              the words carry the reading's language. */}\n          <ol className=\"lk-ra-words\" aria-label={s.pronunciationWordsLabel} dir={contentDir}>\n            {storedMarks.map((entry, index) => {\n              const sentence = markSentence(entry, s);\n              return (\n                <li\n                  // biome-ignore lint/suspicious/noArrayIndexKey: mark order is the identity; words repeat\n                  key={index}\n                  className=\"lk-ra-word\"\n                  data-state={entry.state}\n                >\n                  {/* One channel for assistive technology, not two: the same\n                      sentence as a `title` is an accessible description, read\n                      straight after the name it repeats. */}\n                  <span className=\"lk-visually-hidden\" style={VISUALLY_HIDDEN}>\n                    {sentence}\n                  </span>\n                  <span\n                    className=\"lk-ra-word-text\"\n                    aria-hidden=\"true\"\n                    dir={contentDir ?? 'auto'}\n                    lang={contentLang}\n                  >\n                    {entry.reference}\n                  </span>\n                </li>\n              );\n            })}\n          </ol>\n          {/* Three rows, not four: a stored mark set carries no insertions. */}\n          <ul className=\"lk-ra-legend\">\n            {STORED_STATES.map((state) => (\n              <li key={state} data-state={state}>\n                {s.pronunciationLegend(state)}\n              </li>\n            ))}\n          </ul>\n        </div>\n      ) : null}\n\n      <FeedbackRegion id={`${data.id}-feedback`}>\n        {isReview ? (\n          outcomeReading !== undefined ? (\n            <OutcomeSummary reading={outcomeReading} s={s} scoreShown={gradeShownInPanel} />\n          ) : null\n        ) : gradeShownInPanel ? (\n          // Announced, not repeated. A grade the feedback panel is already\n          // showing would otherwise be read on screen twice, feedback and all —\n          // but a live region is the only thing that TELLS a screen-reader\n          // learner a grade arrived, since nothing takes focus. Clipped rather\n          // than `display: none`, which would stop it being announced at all.\n          <span className=\"lk-visually-hidden\" style={VISUALLY_HIDDEN}>\n            <AnnouncementText announcement={announcement} />\n          </span>\n        ) : (\n          <AnnouncementText announcement={announcement} />\n        )}\n      </FeedbackRegion>\n    </form>\n  );\n}\n","'use client';\n\nimport { useLkStrings } from '../../i18n/LkIntlProvider.js';\nimport { ActivityErrorBoundary } from '../ActivityErrorBoundary.js';\nimport { ReadAloud as ReadAloudCore, type ReadAloudProps } from './ReadAloud.js';\n\n// `RecordedTake` travels with `RecordingBinding` because `upload`, the one\n// method a binding must have, takes one: a binding written against this subpath\n// must not need a second import path to name its own argument.\nexport type { RecordedTake } from '../../hooks/useSpeechRecorder.js';\nexport type { ReadAloudAssessResult, ReadAloudProps, RecordingBinding } from './ReadAloud.js';\n\n/**\n * Public Read Aloud activity: the core wrapped in `ActivityErrorBoundary` so a\n * render failure (including the dev schema-validation throw and the\n * missing-`upload` guard) degrades to an accessible fallback instead of\n * crashing the host.\n */\nexport function ReadAloud(props: ReadAloudProps) {\n  const strings = useLkStrings(props.strings);\n  return (\n    <ActivityErrorBoundary activityTitle={props.data?.title} strings={strings}>\n      <ReadAloudCore {...props} />\n    </ActivityErrorBoundary>\n  );\n}\n"]}

package/dist/chunk-F4TBCRGI.cjs.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/components/shared/read-grade.ts","../src/components/PronunciationFeedback/PronunciationFeedback.tsx","../src/components/PronunciationFeedback/index.tsx"],"names":["validateSpeechAssessment","useLkStrings","useId","useState","useMemo","isDevelopment","ActivitySchemaError","alignReadAloud","useRef","useEffect","localeDirectionOf","jsxs","jsx","Fragment","PronunciationFeedback","ActivityErrorBoundary"],"mappings":"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","file":"chunk-F4TBCRGI.cjs","sourcesContent":["'use client';\n\nimport type {\n  CriterionScore,\n  GradeRecord,\n  ReadAloudDimension,\n  ScoringDetail,\n  ScoringOutcome,\n  SpeechAssessment,\n} from '@intellectif/lk-core';\n\n/**\n * The one reader of a grade that arrives from a host.\n *\n * Nothing validates a `GradeRecord`, an `ItemOutcome` or an assess result on\n * the way in: each is the application's, it crosses a network, and a field a\n * backend serialised as `null`, as a string or as an object is the ordinary way\n * to meet one. Every render path used to dereference them in its own way, so\n * every guard added for one shape left its sibling open — `criteria: null`\n * guarded and `criteria: [null]` not, a numeric `score` guarded and a string\n * `maxScore` shown as 8200%, `feedback` as an object taking a whole activity\n * down, `passed: null` dropping a grade from every callback in development and\n * sending an invalid statement in production.\n *\n * So the question \"what did the host send?\" has one answer, given here. The\n * panel, the outcome summary, the announcement, the decision about who shows\n * the score, `onComplete` and the xAPI statement read ONLY what these functions\n * return, and a payload they refuse is shown as could-not-be-graded — never the\n * error boundary, never `NaN`, never a percentage invented from a string.\n *\n * The rules, once:\n *\n * - **A required field is well-formed or the grade is refused.** `score` and\n *   `maxScore` are finite numbers, `maxScore` above 0 and `score` between 0 and\n *   it; `passed` is a boolean. A numeric string is not a number: `\"100\"` is how\n *   a grade out of 100 turned into 8200%, and coercing it would only move the\n *   guess somewhere else.\n * - **An optional field is absent when it is `undefined` or `null`** — how a\n *   backend writes an absent optional — and otherwise well-formed or dropped.\n *   `feedback` that is not a string is no feedback.\n * - **`criteria` keeps each well-formed entry and drops the rest.** Criteria are\n *   named rows, each independent: an entry that cannot be read names no row.\n * - **`details` is read whole or not at all.** It is the word marks in order,\n *   and a list with one word quietly missing would tell a learner they never\n *   read a word they did.\n * - **Nothing here throws.** A payload whose getter throws is a payload that\n *   cannot be read.\n */\n\n/** Marks a grade as read by {@link readGrade}. Type-only: it never exists at run time. */\ndeclare const READ: unique symbol;\n\n/**\n * A grade {@link readGrade} has checked: `0 <= score <= maxScore`, `maxScore >\n * 0`, both finite, `passed` a boolean, `feedback` a string or `null`, and\n * `criteria` and `details` (when present) holding only well-formed entries.\n * Still a `GradeRecord`, so it can be handed to anything that takes one — and\n * reading it again gives the same grade.\n */\nexport type ReadGrade = GradeRecord & { readonly [READ]: true };\n\n/** A stored outcome, as a renderer may show it. */\nexport type OutcomeReading =\n  /** A grade to show: the outcome's own for `scored`, its `grade` for `graded`. */\n  | { kind: 'graded'; status: 'scored' | 'graded'; grade: ReadGrade }\n  | { kind: 'deferred' }\n  /** `code` is a developer's label: put on an attribute, never shown. */\n  | { kind: 'unscorable'; code: string | undefined }\n  /** Claimed a grade, or claimed nothing a renderer knows, and could not be read. */\n  | { kind: 'unreadable'; status: 'scored' | 'graded' | undefined };\n\n/** An assessor's answer, as a renderer and a statement may use it. */\nexport type AssessReading =\n  | {\n      status: 'graded';\n      /** `null` when what came back cannot be read as a grade. */\n      grade: ReadGrade | null;\n      /** The evidence when it is an object at all; whether it VALIDATES is the panel's question. */\n      assessment: SpeechAssessment | null;\n      recognizedText: string | undefined;\n    }\n  | { status: 'unscorable'; code: string | undefined }\n  | { status: 'failed'; retryable: boolean };\n\n/** One dimension row: a whole percentage, or `undefined` for a dimension nobody measured. */\nexport interface DimensionReading {\n  dimension: ReadAloudDimension;\n  percent: number | undefined;\n}\n\n/**\n * Every dimension a read-aloud grade can weigh, in the order a learner reads\n * them: what was said, how it flowed, how much of it was there, and how it was\n * pitched. Fixed rather than derived from the evidence, so a dimension the\n * engine did not measure is reported as unmeasured instead of vanishing.\n */\nconst DIMENSIONS: readonly ReadAloudDimension[] = [\n  'accuracy',\n  'fluency',\n  'completeness',\n  'prosody',\n];\n\nconst OUTCOMES: readonly ScoringOutcome[] = [\n  'correct',\n  'incorrect',\n  'correct-omission',\n  'incorrect-omission',\n];\n\n/**\n * How far past its own maximum a score may sit and still be read as that\n * maximum. A grader that sums weighted parts lands on `1.0000000000000002`\n * for a perfect take as readily as on `1`, and \"could not be graded\" is the\n * wrong thing to tell the learner who earned it. Far below any difference a\n * whole percentage can show.\n */\nconst OVERSHOOT = 1e-9;\n\nfunction isRecord(value: unknown): value is Record<string, unknown> {\n  return typeof value === 'object' && value !== null && !Array.isArray(value);\n}\n\nfunction isFiniteNumber(value: unknown): value is number {\n  return typeof value === 'number' && Number.isFinite(value);\n}\n\n/** An optional field a backend left out, written either way it writes one. */\nfunction isAbsent(value: unknown): value is null | undefined {\n  return value === undefined || value === null;\n}\n\n/** A score on `0..max`, a hair of overshoot read as `max`; `null` for anything else. */\nfunction withinMax(score: unknown, max: number): number | null {\n  if (!isFiniteNumber(score) || score < 0) {\n    return null;\n  }\n  if (score <= max) {\n    return score;\n  }\n  return score - max <= max * OVERSHOOT ? max : null;\n}\n\n/** A learner's or a reference response: a string, or strings. */\nfunction isResponse(value: unknown): value is string | string[] {\n  return (\n    typeof value === 'string' ||\n    (Array.isArray(value) && value.every((entry) => typeof entry === 'string'))\n  );\n}\n\n/** Runs a read that touches a host's object, whose getters may throw. */\nfunction guarded<T>(read: () => T, refused: T): T {\n  try {\n    return read();\n  } catch {\n    return refused;\n  }\n}\n\nfunction readCriterion(value: unknown): CriterionScore | null {\n  if (!isRecord(value) || typeof value.name !== 'string') {\n    return null;\n  }\n  const { maxScore, notApplicable } = value;\n  if (!isAbsent(maxScore) && !(isFiniteNumber(maxScore) && maxScore > 0)) {\n    return null;\n  }\n  if (!isAbsent(notApplicable) && typeof notApplicable !== 'boolean') {\n    return null;\n  }\n  // `CriterionScore.maxScore` defaults to 1, the SDK's scaled convention.\n  const score = isAbsent(value.score) ? undefined : withinMax(value.score, maxScore ?? 1);\n  if (score === null) {\n    return null;\n  }\n  return {\n    name: value.name,\n    ...(score !== undefined ? { score } : {}),\n    ...(!isAbsent(maxScore) ? { maxScore } : {}),\n    ...(notApplicable === true ? { notApplicable } : {}),\n  };\n}\n\nfunction readDetail(value: unknown): ScoringDetail | null {\n  if (!isRecord(value)) {\n    return null;\n  }\n  const { itemId, correct, outcome, learnerResponse, correctResponse, weight, score } = value;\n  if (\n    typeof itemId !== 'string' ||\n    typeof correct !== 'boolean' ||\n    !isResponse(learnerResponse) ||\n    !isResponse(correctResponse)\n  ) {\n    return null;\n  }\n  const checkedOutcome = OUTCOMES.find((known) => known === outcome);\n  if (!isAbsent(outcome) && checkedOutcome === undefined) {\n    return null;\n  }\n  if (!isAbsent(weight) && !isFiniteNumber(weight)) {\n    return null;\n  }\n  // A detail's own score is a fraction of 1.\n  const checkedScore = isAbsent(score) ? undefined : withinMax(score, 1);\n  if (checkedScore === null) {\n    return null;\n  }\n  return {\n    itemId,\n    correct,\n    learnerResponse,\n    correctResponse,\n    ...(checkedOutcome !== undefined ? { outcome: checkedOutcome } : {}),\n    ...(!isAbsent(weight) ? { weight } : {}),\n    ...(checkedScore !== undefined ? { score: checkedScore } : {}),\n  };\n}\n\nfunction readDetails(value: unknown): ScoringDetail[] | undefined {\n  if (!Array.isArray(value)) {\n    return undefined;\n  }\n  const details: ScoringDetail[] = [];\n  for (const entry of value) {\n    const detail = readDetail(entry);\n    if (detail === null) {\n      return undefined;\n    }\n    details.push(detail);\n  }\n  return details;\n}\n\n/**\n * A host's grade as a checked copy, or `null` when it carries no grade that can\n * be shown or reported. See the module notes for the rules.\n */\nexport function readGrade(value: unknown): ReadGrade | null {\n  return guarded(() => {\n    if (!isRecord(value)) {\n      return null;\n    }\n    const { maxScore, passed } = value;\n    if (!isFiniteNumber(maxScore) || maxScore <= 0 || typeof passed !== 'boolean') {\n      return null;\n    }\n    const score = withinMax(value.score, maxScore);\n    if (score === null) {\n      return null;\n    }\n    const criteria = Array.isArray(value.criteria)\n      ? value.criteria.flatMap((entry) => {\n          const criterion = readCriterion(entry);\n          return criterion === null ? [] : [criterion];\n        })\n      : undefined;\n    const details = readDetails(value.details);\n    const grade: GradeRecord = {\n      score,\n      maxScore,\n      passed,\n      feedback: typeof value.feedback === 'string' ? value.feedback : null,\n      ...(criteria !== undefined ? { criteria } : {}),\n      ...(details !== undefined ? { details } : {}),\n    };\n    return grade as ReadGrade;\n  }, null);\n}\n\n/** A read grade as a fraction of 1: in `0..1`, because the reader made it so. */\nexport function fractionOfGrade(grade: ReadGrade): number {\n  return grade.score / grade.maxScore;\n}\n\n/** A read grade as a whole percentage: in `0..100`, because the reader made it so. */\nexport function percentOfGrade(grade: ReadGrade): number {\n  return Math.round(fractionOfGrade(grade) * 100);\n}\n\n/**\n * A stored outcome as a renderer may show it, or `undefined` for none —\n * `null` included, which is how a backend writes an absent optional.\n *\n * A `graded` outcome is read through its `grade`, the record\n * `outcomeFromGrade` mirrors onto it, so the summary and the panel beside it\n * can never show two different numbers; and it must be well-formed as a whole,\n * its own `score`, `maxScore` and `passed` included — a payload with a corrupt\n * copy of the grade is not one to pick a side of.\n */\nexport function readOutcome(value: unknown): OutcomeReading | undefined {\n  if (isAbsent(value)) {\n    return undefined;\n  }\n  return guarded(\n    (): OutcomeReading => {\n      if (!isRecord(value)) {\n        return { kind: 'unreadable', status: undefined };\n      }\n      switch (value.status) {\n        case 'deferred':\n          return { kind: 'deferred' };\n        case 'unscorable':\n          return {\n            kind: 'unscorable',\n            code: typeof value.code === 'string' ? value.code : undefined,\n          };\n        case 'scored': {\n          const grade = readGrade(value);\n          return grade === null\n            ? { kind: 'unreadable', status: 'scored' }\n            : { kind: 'graded', status: 'scored', grade };\n        }\n        case 'graded': {\n          const grade = readGrade(value.grade);\n          return grade === null || readGrade(value) === null\n            ? { kind: 'unreadable', status: 'graded' }\n            : { kind: 'graded', status: 'graded', grade };\n        }\n        default:\n          return { kind: 'unreadable', status: undefined };\n      }\n    },\n    { kind: 'unreadable', status: undefined },\n  );\n}\n\n/**\n * An assessor's answer as a renderer and a statement may use it.\n *\n * `failed` and `unscorable` need little: a `retryable` that is not `true`\n * offers no retry, which never spends an application's money on a guess, and a\n * `code` that is not a string is no code. Everything else — a `graded` result,\n * and anything that is not an object or names no status this component knows —\n * is read as a judgement: its grade when one can be read, its evidence when it\n * is an object. A judgement with neither is shown as could-not-be-graded.\n */\nexport function readAssessResult(value: unknown): AssessReading {\n  const nothing: AssessReading = {\n    status: 'graded',\n    grade: null,\n    assessment: null,\n    recognizedText: undefined,\n  };\n  return guarded((): AssessReading => {\n    if (!isRecord(value)) {\n      return nothing;\n    }\n    if (value.status === 'failed') {\n      return { status: 'failed', retryable: value.retryable === true };\n    }\n    if (value.status === 'unscorable') {\n      return {\n        status: 'unscorable',\n        code: typeof value.code === 'string' ? value.code : undefined,\n      };\n    }\n    if (value.status !== 'graded') {\n      return nothing;\n    }\n    const assessment = readEvidence(value.assessment);\n    const recognizedText = guarded(\n      () =>\n        typeof assessment?.recognizedText === 'string' ? assessment.recognizedText : undefined,\n      undefined,\n    );\n    return { status: 'graded', grade: readGrade(value.grade), assessment, recognizedText };\n  }, nothing);\n}\n\n/**\n * Evidence worth handing to the panel: an object. Whether it validates is the\n * panel's to decide, because what a refusal costs differs by mode.\n */\nexport function readEvidence(value: unknown): SpeechAssessment | null {\n  return isRecord(value) ? (value as unknown as SpeechAssessment) : null;\n}\n\n/** One criterion's whole percentage of its own maximum, or `undefined` when it carries none. */\nfunction percentOfCriterion(criterion: CriterionScore): number | undefined {\n  if (criterion.notApplicable === true || criterion.score === undefined) {\n    return undefined;\n  }\n  return Math.round((criterion.score / (criterion.maxScore ?? 1)) * 100);\n}\n\n/**\n * The dimension rows, from one source for the whole set and never a mix: the\n * grade's criteria when it has any it can read, and the evidence's own scores\n * otherwise. A dimension pulled out of the evidence and set beside graded ones\n * would read as if it had counted towards the grade.\n *\n * The evidence is read as defensively as the grade: in production the panel\n * shows these rows even for evidence the validator refused, which can carry\n * anything at all under `scores`. `scale` is 100 by schema, so an evidence\n * score is already a percentage — and one outside `0..100` is not one.\n */\nexport function readDimensions(\n  assessment: unknown,\n  grade: ReadGrade | null | undefined,\n): DimensionReading[] {\n  const criteria = grade?.criteria ?? [];\n  if (criteria.length > 0) {\n    return DIMENSIONS.map((dimension) => {\n      const criterion = criteria.find((entry) => entry.name === dimension);\n      return {\n        dimension,\n        percent: criterion === undefined ? undefined : percentOfCriterion(criterion),\n      };\n    });\n  }\n  const scores = guarded(() => (isRecord(assessment) ? assessment.scores : undefined), undefined);\n  return DIMENSIONS.map((dimension) => {\n    const score = withinMax(\n      guarded(() => (isRecord(scores) ? scores[dimension] : undefined), undefined),\n      100,\n    );\n    // Rounded rather than reformatted: the engine's own number is what was graded.\n    return { dimension, percent: score === null ? undefined : Math.round(score) };\n  });\n}\n","'use client';\n\nimport {\n  ActivitySchemaError,\n  alignReadAloud,\n  type GradeRecord,\n  type ReadAloudData,\n  type ReadAloudWordAlignment,\n  type SpeechAssessment,\n  type SpeechPhoneme,\n  type SpeechWord,\n  type ThemeTokens,\n  type ValidationResult,\n  validateSpeechAssessment,\n} from '@intellectif/lk-core';\nimport { type CSSProperties, useEffect, useId, useMemo, useRef, useState } from 'react';\nimport { localeDirectionOf } from '../../i18n/direction.js';\nimport { useLkStrings } from '../../i18n/LkIntlProvider.js';\nimport type { LkStrings, LkStringsOverride } from '../../i18n/strings.js';\nimport { isDevelopment } from '../_internal.js';\nimport { percentOfGrade, readDimensions, readGrade } from '../shared/read-grade.js';\n\n/**\n * Present for assistive technology, invisible on screen. Inline rather than\n * left to the optional skin, for the reason `<Dictation>` gives: the per-word\n * sentences are the marks' only channel for a screen reader, and a page that\n * does not load the skin would otherwise show every one of them beside its\n * word. Exported so `<ReadAloud>`, whose review fallback renders the same\n * marks from stored details, carries one definition rather than a copy.\n */\nexport const VISUALLY_HIDDEN: CSSProperties = {\n  position: 'absolute',\n  width: 1,\n  height: 1,\n  margin: -1,\n  padding: 0,\n  overflow: 'hidden',\n  clip: 'rect(0 0 0 0)',\n  clipPath: 'inset(50%)',\n  whiteSpace: 'nowrap',\n  border: 0,\n};\n\n/** The four marking states, in the order the legend lists them. */\nconst LEGEND_STATES: readonly ReadAloudWordAlignment['state'][] = [\n  'correct',\n  'mispronounced',\n  'omitted',\n  'inserted',\n];\n\nexport interface PronunciationFeedbackProps {\n  /**\n   * The item's reading and its language. Only these two fields, because they\n   * are the only ones a mark depends on — everything else about the activity\n   * belongs to whoever rendered it.\n   */\n  data: Pick<ReadAloudData, 'referenceText' | 'locale'>;\n  /**\n   * The assessor's evidence. Checked with `validateSpeechAssessment` before it\n   * is aligned: see the note on this component about what a bad one costs.\n   */\n  assessment: SpeechAssessment;\n  /**\n   * The grade the evidence produced, when one exists. Its `criteria` are what\n   * the dimensions are read from, because they are the numbers the learner was\n   * actually graded on. A grade that cannot be read — a score that is not a\n   * number between 0 and its maximum, a `passed` that is not a boolean — is\n   * shown as could-not-be-graded, never as a percentage made up from it.\n   */\n  grade?: GradeRecord;\n  /**\n   * The learner's own take, playable. With it, each word that carries timings\n   * gets a button that plays just that word.\n   */\n  audioUrl?: string;\n  /**\n   * Confidence above which a break note is shown, 0..1. **No default**: how\n   * confident an engine has to be before a pause is worth telling a learner\n   * about is a calibration, and the SDK has no calibrated answer. Without it no\n   * break note is shown at all.\n   */\n  breakThreshold?: number;\n  /** The same, for the monotone note read off `assessment.prosody`. */\n  monotoneThreshold?: number;\n  /**\n   * BCP 47 tag stamped as `lang` on the root: the INTERFACE language, the one\n   * this component's own sentences are written in. It is not `data.locale`,\n   * which is the language of the reading and is put on the words themselves.\n   */\n  locale?: string;\n  /** Per-instance token overrides, applied as inline CSS vars on the root. */\n  theme?: Partial<ThemeTokens>;\n  /** Overrides the SDK's chrome text for this panel. See {@link LkIntlProvider}. */\n  strings?: LkStringsOverride;\n}\n\n/**\n * What the validator says about evidence that may not even be readable. Its\n * cross-field rules read the value directly, so a getter that throws escapes\n * it — and evidence that cannot be read is evidence refused, not a reason to\n * take the grade beside it down.\n */\nfunction checkEvidence(assessment: unknown): ValidationResult<SpeechAssessment> {\n  try {\n    return validateSpeechAssessment(assessment);\n  } catch {\n    return {\n      success: false,\n      errors: [{ path: [], message: 'The assessment could not be read.', code: 'unreadable' }],\n    };\n  }\n}\n\n/** Whether a word carries anything a disclosure would have to show. */\nfunction hasDetail(word: SpeechWord | undefined): word is SpeechWord {\n  if (word === undefined) {\n    return false;\n  }\n  return (\n    word.accuracy !== undefined ||\n    (word.syllables !== undefined && word.syllables.length > 0) ||\n    (word.phonemes !== undefined && word.phonemes.length > 0) ||\n    word.breaks !== undefined ||\n    (typeof word.startMs === 'number' && typeof word.durationMs === 'number')\n  );\n}\n\n/** A confidence that clears the caller's threshold. No threshold, no note. */\nfunction past(confidence: number | undefined, threshold: number | undefined): boolean {\n  return (\n    threshold !== undefined &&\n    typeof confidence === 'number' &&\n    Number.isFinite(confidence) &&\n    confidence > threshold\n  );\n}\n\n/** One phoneme, named by its symbol or — when the engine named none — by its place. */\nfunction phonemeLabel(phoneme: SpeechPhoneme, index: number, s: LkStrings): string {\n  return phoneme.symbol ?? s.pronunciationPhonemePosition(index + 1);\n}\n\n/**\n * What a screen reader hears for one marked word — the marks' only channel for\n * assistive technology, since the glyph and the decoration are both hidden from\n * it. Exported because `<ReadAloud>`'s review fallback marks the same four\n * states from stored details, and a second copy of these four sentences would\n * be a second thing to translate.\n *\n * Branches on `state` and **never** on `heard === ''`: an inserted word whose\n * text normalises to nothing carries the empty string too, and would otherwise\n * be announced as an omission.\n */\nexport function markSentence(entry: ReadAloudWordAlignment, s: LkStrings): string {\n  switch (entry.state) {\n    case 'correct':\n      return s.pronunciationWordCorrect(entry.reference);\n    case 'mispronounced':\n      return s.pronunciationWordMispronounced(entry.reference);\n    case 'omitted':\n      return s.pronunciationWordOmitted(entry.reference);\n    default:\n      return s.pronunciationWordInserted(entry.heard);\n  }\n}\n\n/**\n * The per-word marks of a read-aloud take, plus the dimensions they were\n * graded on.\n *\n * **A bad assessment never destroys a good grade.** `alignReadAloud` throws a\n * `TypeError` for evidence `validateSpeechAssessment` refuses, so this\n * component runs the validator first. In development the refusal is thrown as\n * an `ActivitySchemaError`, which is the package's dev-error convention and\n * puts the problem in front of whoever wired the adapter up. In production the\n * dimensions and the grade are rendered and the word list is left out — a\n * learner who earned 82% should see 82%, not \"this activity could not be\n * displayed\" from an error boundary.\n *\n * **Nor does a bad grade take the evidence down.** `grade` is read, not\n * trusted: a score that is not a number between 0 and its maximum, or a\n * `passed` that is not a boolean, is shown as could-not-be-graded beside the\n * dimensions and the marks, and criteria that cannot be read name no dimension.\n *\n * There is **no `renderMode`**: nothing here submits, grades or reveals an\n * answer key. A read-aloud item has none, and the marks exist only once a\n * server has graded the take, so there is no mode in which they must be\n * withheld.\n *\n * ```tsx\n * <PronunciationFeedback\n *   data={item}\n *   assessment={assessment}\n *   grade={grade}\n *   audioUrl={takeUrl}\n *   breakThreshold={0.75}\n *   monotoneThreshold={0.6}\n * />\n * ```\n */\nexport function PronunciationFeedback({\n  data,\n  assessment,\n  grade,\n  audioUrl,\n  breakThreshold,\n  monotoneThreshold,\n  locale,\n  theme,\n  strings,\n}: PronunciationFeedbackProps) {\n  const s = useLkStrings(strings);\n  const ids = useId();\n  const [openWord, setOpenWord] = useState<number | null>(null);\n\n  const checked = useMemo(() => checkEvidence(assessment), [assessment]);\n\n  const devError = useMemo(\n    () =>\n      isDevelopment() && !checked.success\n        ? new ActivitySchemaError('read-aloud', checked.errors)\n        : null,\n    [checked],\n  );\n\n  // The checked copy, never the argument, for the same reason lk-core aligns\n  // from it: a property getter cannot answer the validator one word and the\n  // aligner another.\n  const words = useMemo<ReadAloudWordAlignment[] | null>(\n    () => (checked.success ? alignReadAloud(data, checked.data) : null),\n    [checked, data],\n  );\n\n  // The grade as the one reader of a host's grade reads it: `undefined` when\n  // none was given, and `null` when one was and cannot be shown. Everything\n  // below that shows a number reads this and the dimension rows, never `grade`.\n  const reading = useMemo(\n    () => (grade === undefined || grade === null ? undefined : readGrade(grade)),\n    [grade],\n  );\n  const dimensions = useMemo(() => readDimensions(assessment, reading), [assessment, reading]);\n\n  // The take, for the per-word play buttons. A ref and an effect, never a read\n  // during render: this component server-renders like every other one here.\n  const audioRef = useRef<HTMLAudioElement>(null);\n  const stopRef = useRef<ReturnType<typeof setTimeout> | null>(null);\n  useEffect(\n    () => () => {\n      if (stopRef.current !== null) {\n        clearTimeout(stopRef.current);\n      }\n    },\n    [],\n  );\n\n  // All hooks are called before this throw, so hook order stays stable.\n  if (devError) {\n    throw devError;\n  }\n\n  /** Plays one word out of the take, and stops at the end of it. */\n  const playWord = (startMs: number, durationMs: number): void => {\n    const element = audioRef.current;\n    if (element === null) {\n      return;\n    }\n    if (stopRef.current !== null) {\n      clearTimeout(stopRef.current);\n    }\n    element.currentTime = startMs / 1000;\n    try {\n      void element.play().catch(() => {\n        /* an autoplay refusal is not this component's to report */\n      });\n    } catch {\n      /* an engine with no media stack at all; the button simply does nothing */\n    }\n    stopRef.current = setTimeout(() => {\n      stopRef.current = null;\n      element.pause();\n    }, durationMs);\n  };\n\n  // The reading's own language and the direction its tag names, put on the\n  // words and on nothing else: the sentences beside them are interface text.\n  // No `_`→`-` normalisation, unlike `<Dictation>` — `ReadAloudData.locale` is\n  // canonical by schema, so there is nothing to normalise.\n  const contentLang = typeof data.locale === 'string' ? data.locale : undefined;\n  const contentDir = localeDirectionOf(data.locale);\n\n  const alphabet = checked.success ? checked.data.phonemeAlphabet : undefined;\n  const monotone = checked.success ? checked.data.prosody?.monotoneConfidence : undefined;\n  // Read through `at`, not through an index: `wordIndex` belongs to a public\n  // type a caller may have built by hand, and it is allowed to point nowhere.\n  const evidenceWords: readonly SpeechWord[] = checked.success ? checked.data.words : [];\n\n  return (\n    <section\n      className=\"lk-pf\"\n      aria-label={s.pronunciationFeedbackLabel}\n      lang={locale}\n      style={theme as CSSProperties | undefined}\n    >\n      {reading !== undefined ? (\n        // `.lk-pf-grade` is load-bearing beyond the skin: `<ReadAloud>` looks\n        // for it after the commit to decide whether it must render the score\n        // itself, so a grade is never lost between the two components. It\n        // hands this panel only a grade it has already read, so the block it\n        // finds always carries the score.\n        //\n        // `data-passed` only where there is a verdict: a grade that could not\n        // be read has none, and styling it as a fail would invent one.\n        <div\n          className=\"lk-pf-grade\"\n          {...(reading !== null ? { 'data-passed': String(reading.passed) } : {})}\n        >\n          <p className=\"lk-pf-score\">\n            {reading === null\n              ? s.couldNotBeGraded\n              : s.scoreAnnouncement(percentOfGrade(reading), reading.passed)}\n          </p>\n          {/* The grader's words, isolated: their direction is their own, so an\n              English comment in an Arabic interface keeps its full stop at its\n              end. Their language is not guessed — feedback may be written in\n              either the interface's language or the reading's. */}\n          {reading?.feedback ? (\n            <p className=\"lk-pf-grade-feedback\" dir=\"auto\">\n              {reading.feedback}\n            </p>\n          ) : null}\n        </div>\n      ) : null}\n\n      <dl className=\"lk-pf-dimensions\">\n        {dimensions.map(({ dimension, percent }) => (\n          <div className=\"lk-pf-dimension\" key={dimension} data-dimension={dimension}>\n            <dt className=\"lk-pf-dimension-name\">{s.pronunciationDimension(dimension)}</dt>\n            {/* An absent score is NEVER a 0: a dimension nobody measured and a\n                dimension measured at nothing are different findings, and only\n                one of them is the learner's. */}\n            <dd className=\"lk-pf-dimension-score\">\n              {percent === undefined ? s.pronunciationNotAssessed : `${percent}%`}\n            </dd>\n          </div>\n        ))}\n      </dl>\n\n      {words !== null ? (\n        <>\n          {/* The list's name and the hidden sentences are interface text and\n              keep the interface language; only the words carry the reading's.\n              Its direction is the reading's, never resolved from the list's own\n              text: the first strong character there is a hidden sentence. */}\n          <ol className=\"lk-pf-words\" aria-label={s.pronunciationWordsLabel} dir={contentDir}>\n            {words.map((entry, index) => {\n              const sentence = markSentence(entry, s);\n              const shown = entry.state === 'inserted' ? entry.heard : entry.reference;\n              const word =\n                entry.wordIndex === undefined ? undefined : evidenceWords.at(entry.wordIndex);\n              const open = openWord === index;\n              const panelId = `${ids}-w${index}`;\n              return (\n                <li\n                  // biome-ignore lint/suspicious/noArrayIndexKey: alignment order is the identity; words repeat\n                  key={index}\n                  className=\"lk-pf-word\"\n                  data-state={entry.state}\n                >\n                  {/* The state's only channel for assistive technology, and\n                      exactly one channel: the same sentence as a `title` is an\n                      accessible description, which a screen reader reads\n                      straight after the name it duplicates. */}\n                  <span className=\"lk-visually-hidden\" style={VISUALLY_HIDDEN}>\n                    {sentence}\n                  </span>\n                  {/* Decoration: the glyph the skin draws and the word itself.\n                      Hidden from assistive technology, which already has the\n                      sentence above — and the glyph is never the only channel. */}\n                  <span\n                    className=\"lk-pf-word-text\"\n                    aria-hidden=\"true\"\n                    dir={contentDir ?? 'auto'}\n                    lang={contentLang}\n                  >\n                    {shown}\n                  </span>\n                  {hasDetail(word) ? (\n                    <>\n                      <button\n                        type=\"button\"\n                        className=\"lk-pf-word-toggle\"\n                        aria-expanded={open}\n                        aria-controls={panelId}\n                        onClick={() => setOpenWord(open ? null : index)}\n                      >\n                        {s.pronunciationWordDetails(shown)}\n                      </button>\n                      {open ? (\n                        <div id={panelId} className=\"lk-pf-word-detail\">\n                          <dl className=\"lk-pf-word-facts\">\n                            <dt>{s.pronunciationDimension('accuracy')}</dt>\n                            <dd>\n                              {word.accuracy === undefined\n                                ? s.pronunciationNotAssessed\n                                : `${Math.round(word.accuracy)}%`}\n                            </dd>\n                            {word.syllables !== undefined && word.syllables.length > 0 ? (\n                              <>\n                                <dt>{s.pronunciationSyllables}</dt>\n                                <dd>\n                                  <ul className=\"lk-pf-syllables\">\n                                    {word.syllables.map((syllable, position) => (\n                                      <li\n                                        // biome-ignore lint/suspicious/noArrayIndexKey: syllables are positional and repeat within a word\n                                        key={position}\n                                        dir={contentDir ?? 'auto'}\n                                        lang={contentLang}\n                                      >\n                                        {syllable.grapheme === undefined\n                                          ? syllable.text\n                                          : s.pronunciationSyllableSpelling(\n                                              syllable.text,\n                                              syllable.grapheme,\n                                            )}\n                                      </li>\n                                    ))}\n                                  </ul>\n                                </dd>\n                              </>\n                            ) : null}\n                            {word.phonemes !== undefined && word.phonemes.length > 0 ? (\n                              <>\n                                <dt>{s.pronunciationPhonemes}</dt>\n                                <dd>\n                                  <ul className=\"lk-pf-phonemes\">\n                                    {word.phonemes.map((phoneme, position) => (\n                                      <li\n                                        // biome-ignore lint/suspicious/noArrayIndexKey: a word may sound the same phoneme twice\n                                        key={position}\n                                        className=\"lk-pf-phoneme\"\n                                      >\n                                        <span className=\"lk-pf-phoneme-symbol\">\n                                          {phonemeLabel(phoneme, position, s)}\n                                        </span>\n                                        {phoneme.heardAs !== undefined &&\n                                        phoneme.heardAs.length > 0 ? (\n                                          <>\n                                            <span className=\"lk-pf-heard-label\">\n                                              {s.pronunciationHeardAs}\n                                            </span>\n                                            <ul className=\"lk-pf-heard-as\">\n                                              {phoneme.heardAs.map((candidate, rank) => (\n                                                <li\n                                                  // biome-ignore lint/suspicious/noArrayIndexKey: candidates are ranked and a symbol may repeat\n                                                  key={rank}\n                                                >\n                                                  {candidate.symbol}\n                                                </li>\n                                              ))}\n                                            </ul>\n                                          </>\n                                        ) : null}\n                                      </li>\n                                    ))}\n                                  </ul>\n                                </dd>\n                              </>\n                            ) : null}\n                          </dl>\n                          {audioUrl !== undefined &&\n                          typeof word.startMs === 'number' &&\n                          typeof word.durationMs === 'number' ? (\n                            <button\n                              type=\"button\"\n                              className=\"lk-pf-word-play\"\n                              onClick={() =>\n                                playWord(word.startMs as number, word.durationMs as number)\n                              }\n                            >\n                              {s.pronunciationPlayWord(shown)}\n                            </button>\n                          ) : null}\n                          {past(word.breaks?.unexpected, breakThreshold) ? (\n                            <p className=\"lk-pf-break\" data-break=\"unexpected\">\n                              {s.pronunciationBreakUnexpected}\n                            </p>\n                          ) : null}\n                          {past(word.breaks?.missing, breakThreshold) ? (\n                            <p className=\"lk-pf-break\" data-break=\"missing\">\n                              {s.pronunciationBreakMissing}\n                            </p>\n                          ) : null}\n                        </div>\n                      ) : null}\n                    </>\n                  ) : null}\n                </li>\n              );\n            })}\n          </ol>\n          <ul className=\"lk-pf-legend\">\n            {LEGEND_STATES.map((state) => (\n              <li key={state} data-state={state}>\n                {s.pronunciationLegend(state)}\n              </li>\n            ))}\n          </ul>\n          {/* Only where there are symbols to explain, and only for the alphabet\n              this note names. An engine that reported another one, or none at\n              all, gets no note rather than a wrong one. */}\n          {alphabet === 'ipa' ? <p className=\"lk-pf-alphabet\">{s.pronunciationIpaNote}</p> : null}\n        </>\n      ) : null}\n\n      {past(monotone, monotoneThreshold) ? (\n        <p className=\"lk-pf-monotone\" role=\"note\">\n          {s.pronunciationMonotone}\n        </p>\n      ) : null}\n\n      {audioUrl !== undefined ? (\n        // biome-ignore lint/a11y/useMediaCaption: the learner's own take has no caption track to offer, and this element is never played as content — it carries no controls and exists only so one word can be replayed from a button that names it\n        <audio ref={audioRef} className=\"lk-pf-audio\" src={audioUrl} preload=\"metadata\" />\n      ) : null}\n    </section>\n  );\n}\n","'use client';\n\nimport { useLkStrings } from '../../i18n/LkIntlProvider.js';\nimport { ActivityErrorBoundary } from '../ActivityErrorBoundary.js';\nimport {\n  PronunciationFeedback as PronunciationFeedbackCore,\n  type PronunciationFeedbackProps,\n} from './PronunciationFeedback.js';\n\nexport type { PronunciationFeedbackProps } from './PronunciationFeedback.js';\n\n/**\n * Public pronunciation-feedback panel: the core wrapped in\n * `ActivityErrorBoundary` so a render failure (the dev throw for evidence\n * `validateSpeechAssessment` refuses among them) degrades to an accessible\n * fallback instead of crashing the host.\n *\n * **No `activityTitle`.** Its `data` is two fields of a read-aloud item and\n * carries no title, so the production fallback is the unnamed one. Naming it\n * would mean inventing a title for a panel that never had one.\n */\nexport function PronunciationFeedback(props: PronunciationFeedbackProps) {\n  const strings = useLkStrings(props.strings);\n  return (\n    <ActivityErrorBoundary strings={strings}>\n      <PronunciationFeedbackCore {...props} />\n    </ActivityErrorBoundary>\n  );\n}\n"]}

package/dist/chunk-I33FOKZ7.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/components/ActivitySequence/ActivitySequence.tsx"],"names":[],"mappings":"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","file":"chunk-I33FOKZ7.js","sourcesContent":["'use client';\n\nimport {\n  type ActivityMedia,\n  type ActivityResult,\n  flattenSequence,\n  type InteractionEvent,\n  type ItemOutcome,\n  isItemGroup,\n  type LearnerResponse,\n  type RecordingRef,\n  resolvePlaybackPolicy,\n  type SequenceEntry,\n  type SequenceSlot,\n  type SequenceSlotGroup,\n  type SpeechAssessment,\n  slotMediaKey,\n  stimulusMediaKey,\n  type ThemeTokens,\n} from '@intellectif/lk-core';\nimport { type ComponentType, useEffect, useMemo, useRef, useState } from 'react';\nimport { useLkStrings } from '../../i18n/LkIntlProvider.js';\nimport type { LkStringsOverride } from '../../i18n/strings.js';\nimport { randomSessionId } from '../_internal.js';\nimport { Dictation } from '../Dictation/index.js';\nimport { FillInTheBlanks } from '../FillInTheBlanks/index.js';\nimport { GapSelect } from '../GapSelect/index.js';\nimport { MultipleChoice } from '../MultipleChoice/index.js';\nimport { ReadAloud } from '../ReadAloud/index.js';\nimport type { RecordingBinding } from '../ReadAloud/ReadAloud.js';\nimport { StimulusPanel } from '../StimulusPanel/index.js';\nimport { stopCaptureGroup } from '../shared/capture-registry.js';\nimport {\n  mintTake,\n  type SequenceSlotChannel,\n  SequenceSlotContext,\n  type TakeState,\n  takeOf,\n} from '../shared/sequence-slot.js';\nimport type {\n  ActivityProps,\n  HtmlSanitizer,\n  MediaBudgetBinding,\n  RenderableActivity,\n  RenderMode,\n  SequenceMediaBudget,\n  SequenceRecordingBinding,\n  SequenceRecordingSlot,\n} from '../types.js';\nimport { WrittenResponse, type WrittenResponseSubmission } from '../WrittenResponse/index.js';\n\n/**\n * What one finished slot in a sequence produced. Two kinds, because two kinds\n * of activity exist: those the SDK scores at submit time, and those a grader\n * scores later. Collapsing them would mean inventing a score for ungraded\n * work — the exact defect the deferred outcome exists to prevent.\n *\n * **A read-aloud hand-in adds no arm here, deliberately.** The obvious home for\n * a handed-in take is `submitted`, and it is the wrong one: that arm's payload\n * is typed `WrittenResponseSubmission`, this union is published from both the\n * barrel and the `components/ActivitySequence` subpath, and a consumer narrows\n * on `kind === 'submitted'` and reads `.text`. Widening the payload to a union\n * would break every one of those reads — a breaking change to a published\n * discriminated union, bought for a type that `responded` already describes: a\n * read-aloud hand-in IS a raw `LearnerResponse` with no grade, which is exactly\n * what `responded` carries.\n *\n * What a read-aloud does add is `unsubmitted`, for the one thing no existing\n * arm can say honestly: a take that never reached storage. Any response would\n * be a lie about it — a `recording` of `null` is the blank a learner chooses,\n * and grades as 0.\n */\nexport type SequenceItemOutcome =\n  | {\n      kind: 'scored';\n      /** Presented position. */\n      index: number;\n      /** Slot identity from `flattenSequence` — stable under shuffling; the `slotId` to score with. */\n      slotId: string;\n      activityId: string;\n      result: ActivityResult;\n      /**\n       * The answer this score grades, for a slot whose grade arrives after its\n       * answer was handed in and whose learner may hand in another: a\n       * `practice` read-aloud, whose `response.recording` names the take the\n       * score belongs to. Absent for every other slot, whose score and answer\n       * arrive together.\n       */\n      response?: LearnerResponse;\n    }\n  | {\n      kind: 'submitted';\n      index: number;\n      slotId: string;\n      activityId: string;\n      /** Ungraded submission; the grade arrives asynchronously. */\n      submission: WrittenResponseSubmission;\n    }\n  | {\n      kind: 'restored';\n      index: number;\n      slotId: string;\n      activityId: string;\n      /**\n       * The answer as restored, when one was. A slot can be submitted with no\n       * stored response (a blank the learner committed), so this is optional —\n       * inventing one would be worse than admitting it is absent.\n       */\n      response?: LearnerResponse;\n    }\n  | {\n      kind: 'responded';\n      index: number;\n      slotId: string;\n      activityId: string;\n      /**\n       * The raw answer, with no grade of any kind. This is what an `exam` slot\n       * produces: the client is forbidden to score, so a response is all there\n       * is until the server grades it.\n       *\n       * A read-aloud `recording` of `null` here is always a blank the learner\n       * chose to hand in, never a take that failed to upload — that is\n       * `unsubmitted`.\n       */\n      response: LearnerResponse;\n    }\n  | {\n      /**\n       * A question the learner tried to answer and could not hand in, and then\n       * left: a `practice` read-aloud whose take never reached your storage. It\n       * carries no response, because there is none.\n       *\n       * Deliberately not `responded` with a `recording` of `null`: that is the\n       * blank a learner chooses, and a grader marks it 0 with every word\n       * omitted — which would turn a storage outage into a zero. Grade nothing\n       * for this slot; the learner can still return to it, and a take stored\n       * then reaches you through `onSubmit`.\n       */\n      kind: 'unsubmitted';\n      index: number;\n      slotId: string;\n      activityId: string;\n    };\n\n/**\n * A component that can render one activity inside a sequence. Register one per\n * activity `type` to put a consumer-defined type on screen — the React half of\n * the activity-type registry, matching `registerActivityType` in lk-core.\n */\nexport type ActivityRenderer = ComponentType<ActivityProps>;\n\nexport interface ActivitySequenceProps {\n  /**\n   * The ordered set of entries to present, one question at a time: loose\n   * activities, and item groups — a shared passage, recording or image with\n   * the questions that refer to it. A group's stimulus stays on screen\n   * alongside each of its questions.\n   *\n   * Accepts `redact()` projections. For data straight off a server, pass it\n   * through `asRenderableSequence()` — see that helper for why a cast is\n   * unavoidable there — and set `renderMode=\"exam\"`.\n   */\n  activities: readonly SequenceEntry<RenderableActivity>[];\n  /**\n   * Renderers for activity types beyond the built-ins, keyed by `data.type`.\n   * A key matching a built-in overrides it, so a consumer can replace the\n   * bundled renderer without forking the sequencer.\n   *\n   * A registered renderer is an `ActivityRenderer`, which is\n   * `ComponentType<ActivityProps>` — so it receives the shared prop contract\n   * and nothing beyond it. `shuffleSeed`, `recordingBinding` and `assessment`\n   * are all outside that contract and none of them reaches an override: a\n   * replacement for `read-aloud` has to be given its own binding by whoever\n   * wrote it.\n   */\n  renderers?: Readonly<Record<string, ActivityRenderer>>;\n  /**\n   * Called whenever an individual activity is scored at submit time — the\n   * incremental persist hook.\n   *\n   * `slotId` is the identity to store the result against, NOT `index`.\n   * `index` is where the question was PRESENTED, which is not stable: it moves\n   * under shuffling, and it already differs from the slot identity whenever a\n   * group is present (the second entry of a sequence is presented at index 1\n   * but is slot `\"1.0\"` if it is a group's first question). `composeAssessmentScore`\n   * scores by `slotId`, so persisting `index` cannot be reconciled with it.\n   */\n  onActivityComplete?: (result: ActivityResult, index: number, slotId: string) => void;\n  /**\n   * Called on every submit with the learner's raw response and the identity of\n   * the slot that produced it — before any grading, in every render mode.\n   *\n   * **This is the only response channel an `exam` sequence has.** In `exam`\n   * mode the components never grade, so `onActivityComplete` cannot fire and\n   * `onComplete` never will; without this prop nothing a learner submitted\n   * would reach the consumer at all. Persist `response` against `slotId`.\n   */\n  onSubmit?: (\n    response: LearnerResponse,\n    slot: { slotId: string; index: number; activityId: string },\n  ) => void;\n  /**\n   * Called once every activity has been completed, with the scored results.\n   *\n   * Fires only when EVERY item produced a score. A set containing a\n   * deferred-graded activity (a written response) can never satisfy that, so\n   * use `onFinished` for mixed sets — it is the general completion signal and\n   * reports both kinds of outcome. It also carries `slotId` per item, which\n   * this callback's bare array cannot.\n   *\n   * It fires straight after `onFinished`, with the same results, or never: a\n   * set `onFinished` reported with an ungraded slot is not reported here later,\n   * when a re-recorded take is graded.\n   */\n  onComplete?: (results: ActivityResult[]) => void;\n  /**\n   * Called once every activity has been completed, whether it was scored at\n   * submit time or submitted for later grading. Use this for any set that\n   * mixes graded and deferred-graded activities.\n   *\n   * **Once per set**, and that matters for a `practice` read-aloud, whose grade\n   * arrives after the submit that completed the slot. When the last slot is\n   * filled while a read-aloud's take is still being stored or assessed, this\n   * waits for it and reports the set then — with the grade in place, or with\n   * the slot's raw `responded` outcome when the take came back with no grade.\n   * A take that never settles is a question still being answered, so the set\n   * is not reported while it runs.\n   *\n   * **A failure the learner can still retry is in flight too.** While a take\n   * that failed to upload, or whose assessment failed, is offered \"Try again\"\n   * on the question the learner is looking at, the set is not reported: the\n   * retry may yet store and grade it. It completes once the learner moves to\n   * another question — as the last take the slot stored, or as `unsubmitted`\n   * when it never stored one, which is never a blank.\n   *\n   * **A score and a response always describe the same take.** A read-aloud\n   * recorded again replaces the earlier take's grade with the new take's\n   * `responded`, and a result that arrives for a take the learner has since\n   * replaced, or for a paper no longer on screen, is not recorded at all.\n   *\n   * `onComplete` fires in the same report or not at all, so the two never\n   * describe one set differently. What arrives after the set was reported is\n   * not reported here again, because a consumer who persists on this callback\n   * must not write one attempt twice: a later take reaches you through\n   * `onSubmit`, and its grade through `onActivityComplete`, the per-item persist\n   * hook keyed by `slotId` — which only ever grades the answer `onSubmit` last\n   * reported for that slot.\n   */\n  onFinished?: (items: SequenceItemOutcome[]) => void;\n  /** Forwarded to each activity. */\n  onInteraction?: (event: InteractionEvent) => void;\n  /** Forwarded to each activity. `exam` and `review` disable local scoring. */\n  renderMode?: RenderMode;\n  /**\n   * Binds every budgeted recording in this sequence to a play ledger the\n   * consumer persists.\n   *\n   * The SDK refuses a play; it does not remember one. `plays` seeds the counts\n   * at mount (pass `restoreMediaPlayLedger(plan, stored).entries`), and\n   * `onPlayConsumed` is how a play becomes durable — see\n   * {@link SequenceMediaBudget}.\n   */\n  mediaBudget?: SequenceMediaBudget;\n  /**\n   * Where every read-aloud take in this sequence is stored, and how a\n   * judgement comes back. Required by any `read-aloud` slot outside `review`:\n   * the component refuses to render a recorder whose take is stored nowhere.\n   *\n   * Named `recordingBinding` rather than `recording` because both\n   * `ReadAloudData.recording` (the bounds an item declares) and\n   * `ReadAloudLearnerResponse.recording` (the take a learner handed in) already\n   * exist — the plain name would read as one of those. Same name at both\n   * levels, different types, as `mediaBudget` has.\n   */\n  recordingBinding?: SequenceRecordingBinding;\n  /**\n   * Speech assessments keyed by `slotId`, forwarded to the matching read-aloud\n   * slot so `review` can show the per-word marks behind a stored grade.\n   *\n   * Read LIVE, like `outcomes` and unlike `responses`: an assessment is fetched\n   * beside the attempt it explains and lands after the first paint, and a\n   * mount-only read would show the grade with no marks under it for ever.\n   */\n  assessments?: Readonly<Record<string, SpeechAssessment>>;\n  /** Overrides the SDK's chrome text for this sequence. See {@link LkIntlProvider}. */\n  strings?: LkStringsOverride;\n  /**\n   * `entries` shuffles the top-level entries; a group moves as one block, and\n   * the order INSIDE a group follows the group's own `shuffle` setting.\n   * Default `none`: authored order.\n   */\n  shuffle?: 'none' | 'entries';\n  /**\n   * Seed for every shuffle in this sequence (`shuffle: 'entries'` and any\n   * group with `shuffle: 'within-group'`). Supply the attempt id, so the\n   * server's `flattenSequence(entries, { seed })` derives the same order this\n   * pager shows.\n   *\n   * **Required whenever this sequence shuffles** — `shuffle: 'entries'`, or any\n   * group with `shuffle: 'within-group'` — in `exam` or `review` mode; omitting\n   * it then throws. An order nobody can reproduce cannot be reconciled with a\n   * recorded attempt, and failing at render is the only way that mistake\n   * surfaces before a learner sits the paper. A sequence that does not shuffle\n   * needs no seed in any mode.\n   *\n   * The guard covers an activity's own `data.shuffle` too, a group's items\n   * included: `<MultipleChoice>` would otherwise fall back to a per-mount seed,\n   * in every mode.\n   *\n   * In `practice` mode it stays optional: a random per-mount seed is used,\n   * stable within the mount and deliberately not reproducible. That fallback is\n   * also not SSR-safe (server and client would invent different orders and\n   * hydration would mismatch), so supply a seed for any server-rendered\n   * sequence regardless of mode.\n   */\n  shuffleSeed?: string;\n  /**\n   * Where to open. Defaults to the first question; pass a stored\n   * `AttemptState.index` to reopen an interrupted attempt where it was left.\n   * Read at mount only, like any `default*` prop.\n   */\n  defaultIndex?: number;\n  /**\n   * Fires whenever the learner moves. Persist it and the next resume reopens\n   * on the right question — without it, the pager's position is the one piece\n   * of an attempt a consumer cannot recover.\n   */\n  onIndexChange?: (index: number) => void;\n  /**\n   * Answers to restore, keyed by `slotId`, seeded into each slot as its\n   * `defaultValue`. This is the other half of resume: `AttemptState.responses`\n   * goes straight in.\n   *\n   * Read at mount only. To restore a different attempt, remount with a `key`.\n   */\n  responses?: Readonly<Record<string, LearnerResponse>>;\n  /**\n   * Slots the learner had already submitted, from `AttemptState.submittedSlotIds`.\n   * Each is mounted already submitted, so a resumed paper does not reopen a\n   * locked question as answerable — without this a learner can change and\n   * re-submit work they had already committed.\n   *\n   * Read at mount only, alongside `responses`.\n   */\n  submittedSlotIds?: readonly string[];\n  /**\n   * Server-computed outcomes keyed by `slotId`, forwarded to each slot. In\n   * `review` mode this is what marks correctness — the client never scores, so\n   * without it a review render has nothing to show.\n   */\n  outcomes?: Readonly<Record<string, ItemOutcome>>;\n  /** Renders author-supplied rich text; forwarded to the stimulus panel and every activity. */\n  sanitizeHtml?: HtmlSanitizer;\n  theme?: Partial<ThemeTokens>;\n  /**\n   * BCP 47 tag stamped as `lang` on this component's root. This is the\n   * INTERFACE language — the SDK's own chrome renders inside that element — so\n   * it should carry the same value you give `<LkIntlProvider locale>`. Passing\n   * a different one re-declares the language of every SDK string in this\n   * subtree without changing the words.\n   *\n   * It is NOT `data.locale`, which labels xAPI statements — and, on a\n   * dictation, places the dictation's own words: `<Dictation>` puts it, and\n   * the direction it names, on its title, hints, marks and solution. Other\n   * authored content in another language belongs on `stimulus.locale`, which\n   * `<StimulusPanel>` puts on the passage alone.\n   */\n  locale?: string;\n  disabled?: boolean;\n}\n\n/** One stimulus panel to keep mounted: the group, and the presented span of its questions. */\ninterface StimulusMount {\n  /** Authored entry position — unique per group in the sequence even if two groups share an id. */\n  entryKey: string;\n  group: SequenceSlotGroup;\n  first: number;\n  last: number;\n}\n\n/** The authored-entry prefix of a slot id: `\"3\"` for `\"3\"` and for `\"3.1\"`. */\nfunction entryKeyOf(slot: SequenceSlot<RenderableActivity>): string {\n  return slot.slotId.split('.')[0] ?? slot.slotId;\n}\n\n/** The latest take a slot has been told about, and how far it has got. */\ninterface SlotTake {\n  /** A number from `mintTake`: unique on the page, larger for a later take. */\n  take: number;\n  state: TakeState;\n  /** The answer the take was handed in as, once it was stored. */\n  response?: LearnerResponse;\n}\n\n/**\n * Names the capture groups of one pager, so a slot's microphone belongs to that\n * pager alone. Per mount, for the reason the playback groups are: slot ids are\n * short and repeat (\"0\", \"1.0\"), so two pagers on one page — a review beside a\n * live attempt — would share a group, and hiding one's first question would\n * stop the other's recorder. The name never reaches the DOM, so a server and\n * the client that hydrates it may mint different ones.\n */\nlet captureScopeCount = 0;\n\n/**\n * A pane that is kept MOUNTED but shown only when it is the current one, and\n * that stops any media it contains on the way out.\n *\n * `hidden` alone is not enough. It resolves to `display: none`, and CSS does\n * not touch playback: an `<audio>` or `<video>` inside a hidden subtree keeps\n * playing to the end. (The HTML spec pauses a media element when it is\n * REMOVED from the document — a different thing, and the thing this pager\n * deliberately does not do, because unmounting is what used to destroy the\n * learner's answers.) So a recording started for one question would carry on\n * underneath the next, which for a listening paper means the passage plays\n * while the learner is somewhere else entirely.\n *\n * Pausing preserves `currentTime`: coming back to a group resumes where the\n * learner left off. Nothing auto-plays on the way in — starting audio the\n * learner did not ask for is its own defect.\n *\n * `embed` media (a provider iframe) cannot be paused this way: controlling a\n * third-party player needs its own JS API, which the SDK has no reliable\n * access to because the author supplies the embed URL. Use `audio`/`video`\n * media for anything that must stop when the learner navigates.\n *\n * A microphone is the other way round: it is not an element in this subtree, so\n * no query can find it. A slot pane hands its content a `channel` through\n * `SequenceSlotContext` — never a prop, so nothing on a public component's\n * signature can name it — whose `captureGroup` the pane's recorders join, and\n * hiding the pane stops them: a learner who navigates away mid-take must not\n * leave the microphone live under the next question.\n */\nfunction SequencePane({\n  className,\n  hidden,\n  channel,\n  children,\n}: {\n  className: string;\n  hidden: boolean;\n  channel?: SequenceSlotChannel;\n  children: React.ReactNode;\n}): React.JSX.Element {\n  const ref = useRef<HTMLDivElement>(null);\n  const captureGroup = channel?.captureGroup;\n\n  useEffect(() => {\n    if (!hidden) {\n      return;\n    }\n    if (captureGroup !== undefined) {\n      stopCaptureGroup(captureGroup);\n    }\n    const node = ref.current;\n    if (node === null) {\n      return;\n    }\n    for (const media of node.querySelectorAll('audio, video')) {\n      const element = media as HTMLMediaElement;\n      if (!element.paused) {\n        element.pause();\n      }\n    }\n  }, [hidden, captureGroup]);\n\n  return (\n    <div className={className} hidden={hidden} ref={ref}>\n      {channel === undefined ? (\n        children\n      ) : (\n        <SequenceSlotContext.Provider value={channel}>{children}</SequenceSlotContext.Provider>\n      )}\n    </div>\n  );\n}\n\n/**\n * Presents a set of activities as an in-place pager: one question visible at a\n * time, navigated with Prev/Next (no page scrolling). Linear free navigation —\n * the learner may move back and forth; activities keep their own submit and\n * scoring. On navigation, focus moves to the question region and the position\n * is announced via an aria-live region.\n *\n * Item groups are flattened into consecutive questions; the group's stimulus\n * is mounted ONCE, beside the question region rather than inside it, and shown\n * alongside every question in the group — so a passage stays put, and a\n * recording keeps its position, as the learner moves between its questions.\n */\n/**\n * Whether an activity shuffles its own options, and therefore needs a seed of\n * its own. Read structurally: `shuffle` is a per-type content field, not part\n * of the sequence entry contract.\n */\nfunction shufflesItsOwnOptions(entry: unknown): boolean {\n  const item = entry as { shuffle?: unknown; shuffleChoices?: unknown } | null;\n  // Two content fields, one question: does this item deal an order of its own?\n  // `shuffle` is MultipleChoice's; `shuffleChoices` is Gap Select's. A type\n  // added without being named here shuffles unseeded in an exam — and one named\n  // here but not in the seed guard's message sends its author looking for a\n  // shuffle they never wrote.\n  return item?.shuffle === true || item?.shuffleChoices === true;\n}\n\nexport function ActivitySequence({\n  activities,\n  renderers,\n  onActivityComplete,\n  onComplete,\n  onFinished,\n  onSubmit,\n  onInteraction,\n  renderMode = 'practice',\n  shuffle,\n  shuffleSeed,\n  defaultIndex,\n  onIndexChange,\n  responses,\n  submittedSlotIds,\n  outcomes,\n  sanitizeHtml,\n  theme,\n  locale,\n  disabled,\n  mediaBudget,\n  recordingBinding,\n  assessments,\n  strings,\n}: ActivitySequenceProps): React.JSX.Element {\n  const sessionIdRef = useRef<string | null>(null);\n  const s = useLkStrings(strings);\n  const mediaPlays = mediaBudget?.plays;\n  const [captureScope] = useState(() => {\n    captureScopeCount += 1;\n    return `lk-seq-capture-${captureScopeCount}`;\n  });\n\n  // The presented order comes from lk-core, never computed here: the server\n  // that records an attempt calls the same function with the same seed.\n  const shuffleEntries = shuffle === 'entries';\n  // Every shuffle this sequence can produce, not just the ones it performs\n  // itself. An ACTIVITY's own `data.shuffle` is the third source: MultipleChoice\n  // falls back to a per-mount seed when none reaches it, so an unseeded item\n  // shuffle used to render happily under `exam` and hand the learner a\n  // different option order on every mount — exactly the unreproducible\n  // arrangement this guard exists to refuse, arriving through the one door it\n  // did not watch.\n  const needsSeed =\n    shuffleEntries ||\n    activities.some((entry) =>\n      isItemGroup(entry)\n        ? entry.shuffle === 'within-group' || entry.items.some(shufflesItsOwnOptions)\n        : shufflesItsOwnOptions(entry),\n    );\n\n  // An unreproducible order is a practice-only affordance. Under `exam` or\n  // `review` the server has to be able to rebuild exactly what the learner\n  // saw, so a missing seed is an error rather than something to paper over —\n  // the same reason `flattenSequence` refuses to invent one.\n  if (needsSeed && shuffleSeed === undefined && renderMode !== 'practice') {\n    // Every door `needsSeed` watches, named: a reader whose only shuffle is an\n    // item's own field must find that field here. And no single function\n    // rebuilds all of these orders — `flattenSequence` deals entries and group\n    // items, while an item deals its own options from the same seed — so the\n    // message promises the seed, not a function.\n    throw new Error(\n      `ActivitySequence: renderMode \"${renderMode}\" requires a \\`shuffleSeed\\` when anything ` +\n        'in the sequence shuffles: shuffle=\"entries\", a group with shuffle: \"within-group\", or ' +\n        \"an activity's own `data.shuffle` (multiple choice) or `data.shuffleChoices` (gap \" +\n        'select), including an activity inside a group. Pass the attempt id, so the server can ' +\n        'rebuild every order the learner saw from that one seed.',\n    );\n  }\n\n  // Lazily created only when shuffling in practice without a caller seed (same\n  // contract as MultipleChoice.shuffleSeed): a per-mount session seed, stable\n  // across re-renders, never reproducible.\n  const seed = needsSeed\n    ? // biome-ignore lint/suspicious/noAssignInExpressions: sanctioned lazy ref initialization\n      (shuffleSeed ?? (sessionIdRef.current ??= randomSessionId()))\n    : undefined;\n  const slots = useMemo(\n    () => flattenSequence(activities, { shuffleEntries, ...(seed !== undefined ? { seed } : {}) }),\n    [activities, shuffleEntries, seed],\n  );\n\n  // Clamped rather than trusted: a stored position from a paper that has since\n  // lost its last question would open the pager on a slot that is not there,\n  // which renders as an empty shell with no way forward.\n  const [index, setIndex] = useState(() => {\n    // NaN passes through Math.min/Math.max unchanged, so it survived every\n    // clamp and indexed the slots with NaN — the pager then rendered the empty\n    // shell this clamp exists to prevent. `NaN` is a `number`, so the prop type\n    // gives no protection, and `Number(row.last_index)` on a NULL column\n    // produces exactly that.\n    const requested = Math.trunc(defaultIndex ?? 0);\n    if (!Number.isFinite(requested)) {\n      return 0;\n    }\n    return Math.min(Math.max(0, requested), Math.max(0, slots.length - 1));\n  });\n  // Outcomes live in a ref, not state: nothing renders from them, and a ref is\n  // written SYNCHRONOUSLY. Reading them from a `useState` closure meant two\n  // slots completing in the same tick both saw the pre-update array — the\n  // second overwrote the first, so one answer vanished and completion never\n  // fired. Every slot is mounted at once here, so same-tick completions are\n  // reachable (a custom renderer that completes from a mount effect).\n  const outcomesRef = useRef<(SequenceItemOutcome | null)[] | null>(null);\n  // The slot each position of `outcomesRef` belongs to, assigned wherever that\n  // array is created so the two can never describe different papers. A ref,\n  // not the `slots` a closure saw: an outcome that settles late arrives through\n  // a closure from the render that started it, and only a ref can tell it what\n  // is at its position NOW — see `record`.\n  const outcomeSlotsRef = useRef<readonly SequenceSlot<RenderableActivity>[] | null>(null);\n  // The latest take each `practice` read-aloud slot has been told about, keyed\n  // by position — see `record`. A ref for the reason the outcomes are one: a\n  // submit, the grade after it and the report all read it inside one tick.\n  const takesRef = useRef<Map<number, SlotTake>>(new Map());\n  // Which set the outcomes describe: bumped on every set change, and captured\n  // by every callback a render hands a slot. A result that arrives through a\n  // callback from an earlier set is refused, whatever slot and activity ids the\n  // new set reuses — ids a host chooses, and a loading blip or a paper that\n  // shares an item repeats them exactly.\n  const setGenerationRef = useRef(0);\n  // The question on screen, as of the last commit: leaving a question is what\n  // completes a failure on it that was being offered a retry, and a report made\n  // on a position the screen does not show yet would describe a question the\n  // learner is still looking at. Written by the effect below `go`.\n  const indexRef = useRef(index);\n  // Whether this set has been reported. One flag for both whole-set callbacks,\n  // because they are one report: a set can be filled again after it reported —\n  // a practice read-aloud recorded again replaces its own outcome — and a\n  // consumer who persists on either callback must not be handed one attempt\n  // twice, nor be told by `onComplete` later what `onFinished` reported\n  // differently.\n  const reportedRef = useRef(false);\n  // The channel each slot pane hands its content, one per slot per set, so it\n  // keeps one identity for as long as its set is on screen.\n  const channelsRef = useRef<Map<string, SequenceSlotChannel>>(new Map());\n  // What a channel calls, as of the latest render — assigned below `updateTake`.\n  const latestRef = useRef<{\n    updateTake: (generation: number, at: number, take: number, state: TakeState) => void;\n    reportIfFinished: () => void;\n  } | null>(null);\n  // Cleared as this pager unmounts. A slot's own teardown tells the pager its\n  // take is over, and a pager on its way out must not report a set on the\n  // strength of that.\n  const aliveRef = useRef(true);\n  useEffect(() => {\n    aliveRef.current = true;\n    return () => {\n      aliveRef.current = false;\n    };\n  }, []);\n  if (outcomesRef.current === null) {\n    // Slots the learner had already submitted are seeded as `restored`. They\n    // will not submit again — they mount locked — so leaving them null meant\n    // `onFinished` waited forever on outcomes that could never arrive, and a\n    // resumed attempt could never signal completion however many of the\n    // remaining questions the learner answered. Seeding fires no callback: the\n    // attempt was already this far along before this mount existed.\n    const submittedAtMount = new Set(submittedSlotIds ?? []);\n    outcomesRef.current = slots.map((slot) =>\n      submittedAtMount.has(slot.slotId)\n        ? {\n            kind: 'restored' as const,\n            index: slot.index,\n            slotId: slot.slotId,\n            activityId: slot.activity.id,\n            ...(responses !== undefined && Object.hasOwn(responses, slot.slotId)\n              ? { response: responses[slot.slotId] as LearnerResponse }\n              : {}),\n          }\n        : null,\n    );\n    outcomeSlotsRef.current = slots;\n  }\n  const regionRef = useRef<HTMLDivElement>(null);\n  const mountedRef = useRef(false);\n\n  // Reset pager position and outcomes when the presented SET changes (B8):\n  // without this, results from the previous set leak into the new one and can\n  // fire completion with a mixed old/new array. Keyed on the set's CONTENT\n  // identity (ordered slot and activity ids), not the array reference — a\n  // parent that re-creates a structurally identical array on every render\n  // (inline literals, .map() in render) must not wipe in-progress answers.\n  // JSON.stringify (not join) so ids containing the separator cannot collide.\n  const setKey = JSON.stringify(slots.map((slot) => [slot.slotId, slot.activity.id]));\n  const [prevSetKey, setPrevSetKey] = useState(setKey);\n  // The set this component mounted with. `responses` seeds slots BY slotId,\n  // and slot ids are short and repeat across papers (\"0\", \"1.0\"), so applying\n  // them after the set changed would drop one paper's answers under another\n  // paper's questions — a review modal stepping to the next attempt did\n  // exactly that. Seeding stops at the first set change; to show a different\n  // attempt, remount with a `key`, which is what \"read at mount only\" means.\n  // `mediaBudget.resumeKey` participates so an invigilator can hand a play\n  // back — re-seeding the budgets in place — without remounting the pager and\n  // costing the learner their focus, their scroll position and an unsaved\n  // answer.\n  const seedKey = `${setKey}::${mediaBudget?.resumeKey ?? ''}`;\n  const mountSetKeyRef = useRef(setKey);\n  const mountSeedKeyRef = useRef(seedKey);\n  const seedsApply = mountSetKeyRef.current === setKey;\n  const mediaSeedsApply = mountSeedKeyRef.current === seedKey || seedsApply;\n  if (mountSeedKeyRef.current !== seedKey) {\n    mountSeedKeyRef.current = seedKey;\n  }\n  const submitted = useMemo(() => new Set(submittedSlotIds ?? []), [submittedSlotIds]);\n  if (prevSetKey !== setKey) {\n    setPrevSetKey(setKey);\n    setIndex(0);\n    // At once, not in the effect: a new set has no question the learner was on,\n    // and the effect does not run at all when the position was already 0.\n    indexRef.current = 0;\n    outcomesRef.current = slots.map(() => null);\n    outcomeSlotsRef.current = slots;\n    takesRef.current = new Map();\n    setGenerationRef.current += 1;\n    channelsRef.current = new Map();\n    reportedRef.current = false;\n  }\n  const setGeneration = setGenerationRef.current;\n\n  // After a navigation (not the initial mount) move focus to the question\n  // region so screen-reader / keyboard users land on the new question.\n  // biome-ignore lint/correctness/useExhaustiveDependencies: index is the intended trigger\n  useEffect(() => {\n    if (mountedRef.current) {\n      regionRef.current?.focus();\n    } else {\n      mountedRef.current = true;\n    }\n  }, [index]);\n\n  // Report where the pager actually IS, from an effect rather than from the\n  // navigation handler. Two positions the learner never chose are still\n  // positions a consumer has to persist: a `defaultIndex` that was clamped\n  // (stored 99, showing 2) and the reset a set change performs. Reporting only\n  // clicks left storage disagreeing with the screen, and the next autosave\n  // then wrote a position the plan does not have.\n  const reportedIndexRef = useRef<number | null>(null);\n  useEffect(() => {\n    if (reportedIndexRef.current === index) {\n      return;\n    }\n    const first = reportedIndexRef.current === null;\n    reportedIndexRef.current = index;\n    // On mount, stay silent unless the requested position was corrected.\n    if (first && index === Math.trunc(defaultIndex ?? 0)) {\n      return;\n    }\n    onIndexChange?.(index);\n  }, [index, defaultIndex, onIndexChange]);\n\n  // The learner has moved, and the screen shows where to. Leaving a question\n  // can complete a failure on it that was being offered a retry — see\n  // `reportIfFinished` — so the set may be reportable now.\n  useEffect(() => {\n    if (indexRef.current === index) {\n      return;\n    }\n    indexRef.current = index;\n    latestRef.current?.reportIfFinished();\n  }, [index]);\n\n  // One panel per group, spanning the presented positions of its questions.\n  const stimulusMounts = useMemo<StimulusMount[]>(() => {\n    const mounts = new Map<string, StimulusMount>();\n    for (const slot of slots) {\n      if (slot.group === undefined) {\n        continue;\n      }\n      const entryKey = entryKeyOf(slot);\n      const existing = mounts.get(entryKey);\n      if (existing === undefined) {\n        mounts.set(entryKey, { entryKey, group: slot.group, first: slot.index, last: slot.index });\n      } else {\n        existing.last = slot.index;\n      }\n    }\n    return [...mounts.values()];\n  }, [slots]);\n\n  const total = slots.length;\n  const current = slots[index];\n\n  const go = (next: number): void => {\n    setIndex(next);\n  };\n\n  /**\n   * Fires the whole-set callbacks — once, together — when every slot is done\n   * and no take is still on its way.\n   *\n   * **A take on its way holds the report.** A practice read-aloud records its\n   * `responded` outcome the moment its take is stored, and its grade can land\n   * after the last slot was filled; reporting then handed `onFinished` the raw\n   * outcome, and the grade a moment later could never reach it. So a slot\n   * whose latest take is being stored or judged is not done. The take states\n   * come from the component itself, through the slot's channel, and every way a\n   * take can end reports an end — a grade, a take with no grade, a failure\n   * nobody can retry, an unmount — so a take that settles never holds a set.\n   *\n   * **So does a failure the learner can still retry, on the question in front\n   * of them.** Reporting there reported a set whose answer \"Try again\" was about\n   * to change: the retry stored and graded the take, and `onComplete` then\n   * described a different set from the `onFinished` before it. Once the learner\n   * moves to another question the failure no longer holds the report: the slot\n   * completes as whatever it last stored, or as `unsubmitted` when that is\n   * nothing — never as a `recording` of `null`, which is the blank a learner\n   * chooses and a grader marks 0. `unsubmitted` is a `practice` outcome only:\n   * an exam question with no stored take is unanswered, and the learner has a\n   * blank to hand in if that is their answer.\n   */\n  const reportIfFinished = (): void => {\n    const held = outcomesRef.current;\n    const presented = outcomeSlotsRef.current;\n    if (held === null || presented === null || reportedRef.current) {\n      return;\n    }\n    const items: SequenceItemOutcome[] = [];\n    for (const [at, outcome] of held.entries()) {\n      const take = takesRef.current.get(at);\n      if (take?.state === 'in-flight' || (take?.state === 'retryable' && at === indexRef.current)) {\n        return;\n      }\n      const slot = presented[at];\n      if (outcome !== null) {\n        items.push(outcome);\n      } else if (take?.state === 'retryable' && renderMode === 'practice' && slot !== undefined) {\n        items.push({\n          kind: 'unsubmitted',\n          index: at,\n          slotId: slot.slotId,\n          activityId: slot.activity.id,\n        });\n      } else {\n        return;\n      }\n    }\n    reportedRef.current = true;\n    onFinished?.(items);\n\n    // `onComplete` predates deferred grading and promises ActivityResult[].\n    // Fire it only when every slot really was scored, rather than inventing a\n    // result for work nobody has graded — and only here, beside `onFinished`.\n    const scored: ActivityResult[] = [];\n    for (const item of items) {\n      if (item.kind !== 'scored') {\n        return;\n      }\n      scored.push(item.result);\n    }\n    onComplete?.(scored);\n  };\n\n  /**\n   * Records a finished slot and reports the set when it is done — the one place\n   * a slot's outcome is decided.\n   *\n   * **An outcome must come from the set on screen.** A grade can settle after\n   * the paper changed — an assessment held across a swap of `activities`, or a\n   * consumer's own renderer grading asynchronously — and it arrives through a\n   * callback from the render that started it. Accepted, it landed in whatever\n   * slot of the NEW paper had its index, and could report that paper fully\n   * scored though nobody had answered it. Ids cannot tell the papers apart: a\n   * new paper can reuse both the slot id and the activity id, and a loading\n   * blip reuses every id there is. `generation` can: it is the set the callback\n   * was handed out for, and it is refused unless that set is still current.\n   *\n   * **A slot that already holds an outcome is FINAL**: the first outcome wins,\n   * so a renderer that reports twice keeps what it reported first. There is one\n   * exception.\n   *\n   * **The exception is a `practice` read-aloud, and it is decided by `take`.**\n   * That slot records `responded` when a take is stored, because a take that\n   * comes back unscorable produces no grade at all and the slot would otherwise\n   * stay `null` for ever. Each take has a number (`mintTake`), unique on the page\n   * and larger for a later take, carried by everything the component reports\n   * about it. The invariant:\n   *\n   * **The score and the response a slot holds always describe the same take.**\n   *\n   * - A `responded` for a newer take replaces whatever the slot holds, a grade\n   *   included: `onSubmit` has already told the host about that take, so a\n   *   grade kept for the older one would sit beside a response it does not\n   *   grade.\n   * - A `scored` lands only for the slot's latest take, once, and replaces that\n   *   take's `responded`. A grade for any other take — one the learner has\n   *   since replaced, even one still in flight when they did — is dropped\n   *   rather than filed against a take it did not grade.\n   * - A `restored` slot is never replaced: it was submitted before this mount,\n   *   and a resumed attempt must not be re-reported as if it had just been sat.\n   *\n   * A grade therefore lands once per take, and `onActivityComplete` — the\n   * per-item hook, keyed by `slotId` — only ever grades the answer `onSubmit`\n   * last reported for that slot. The whole-set callbacks stay once per set\n   * whatever is replaced — see `reportedRef`.\n   */\n  const record = (outcome: SequenceItemOutcome, generation: number, take?: number): void => {\n    const held = outcomesRef.current;\n    if (held === null || generation !== setGenerationRef.current) {\n      return;\n    }\n    const at = outcome.index;\n    const holding = held[at];\n    let accepted = outcome;\n    if (take === undefined) {\n      if (holding != null) {\n        return;\n      }\n    } else {\n      if (holding?.kind === 'restored') {\n        return;\n      }\n      const latest = takesRef.current.get(at);\n      if (outcome.kind === 'responded') {\n        // Older than the latest take, or a second answer for the same one.\n        if (\n          latest !== undefined &&\n          (take < latest.take || (take === latest.take && latest.response !== undefined))\n        ) {\n          return;\n        }\n        takesRef.current.set(at, {\n          take,\n          // A take this pager hears of first through its answer — a consumer's\n          // renderer has no channel — has nothing on its way.\n          state: latest?.take === take ? latest.state : 'settled',\n          response: outcome.response,\n        });\n      } else if (outcome.kind === 'scored') {\n        // Only the latest take's grade, only once it was stored, and only once.\n        if (latest?.take !== take || latest.response === undefined || holding?.kind === 'scored') {\n          return;\n        }\n        accepted = { ...outcome, response: latest.response };\n      } else {\n        return;\n      }\n    }\n    const next = held.slice();\n    next[at] = accepted;\n    // Commit before firing anything: a second record() in the same tick must\n    // see this one.\n    outcomesRef.current = next;\n\n    if (accepted.kind === 'scored') {\n      onActivityComplete?.(accepted.result, accepted.index, accepted.slotId);\n    }\n    reportIfFinished();\n  };\n\n  /**\n   * What a slot's channel reports: the state of one of its takes. A take older\n   * than the slot's latest has been replaced, and a report from a set that is\n   * no longer current, or reaching a pager that is unmounting, describes\n   * nothing on screen.\n   */\n  const updateTake = (generation: number, at: number, take: number, state: TakeState): void => {\n    if (!aliveRef.current || generation !== setGenerationRef.current) {\n      return;\n    }\n    const latest = takesRef.current.get(at);\n    if (latest !== undefined && take < latest.take) {\n      return;\n    }\n    // A newer take starts with no answer of its own: the response the slot\n    // holds belongs to the take before it until this one is stored.\n    takesRef.current.set(at, latest?.take === take ? { ...latest, state } : { take, state });\n    reportIfFinished();\n  };\n  // Channels keep one identity for a whole set, so they call through this ref\n  // and always reach the latest render's props.\n  latestRef.current = { updateTake, reportIfFinished };\n\n  /** The channel a slot's pane hands its content: its capture group and its takes. */\n  const channelFor = (slot: SequenceSlot<RenderableActivity>): SequenceSlotChannel => {\n    const key = `${slot.index}::${slot.slotId}`;\n    let channel = channelsRef.current.get(key);\n    if (channel === undefined) {\n      const generation = setGeneration;\n      const at = slot.index;\n      channel = {\n        captureGroup: `${captureScope}::${slot.slotId}`,\n        takeState: (take, state) => {\n          latestRef.current?.updateTake(generation, at, take, state);\n        },\n      };\n      channelsRef.current.set(key, channel);\n    }\n    return channel;\n  };\n\n  if (!current) {\n    return <div className=\"lk-seq\" />;\n  }\n\n  // Every budgeted recording this paper presents, and the key it is budgeted\n  // under. Derived from the resolved policy, so the pager, the plan and the\n  // schema cannot disagree about what is budgeted.\n  const budgetedMedia = slots.flatMap((slot) => {\n    const found: { key: string; url: string }[] = [];\n    const own = (slot.activity as { media?: ActivityMedia }).media;\n    if (own !== undefined && resolvePlaybackPolicy(own).maxPlays !== null) {\n      found.push({ key: slotMediaKey(slot.slotId), url: own.url });\n    }\n    const stimulus = slot.group?.stimulus.media;\n    if (stimulus !== undefined && resolvePlaybackPolicy(stimulus).maxPlays !== null) {\n      found.push({ key: stimulusMediaKey(slot.slotId), url: stimulus.url });\n    }\n    return found;\n  });\n\n  const budgetEnforced = mediaBudget?.enforced ?? renderMode !== 'review';\n\n  if (budgetedMedia.length > 0 && renderMode === 'exam' && budgetEnforced) {\n    if (mediaBudget?.onPlayConsumed === undefined) {\n      throw new Error(\n        'ActivitySequence: renderMode \"exam\" with media that declares `maxPlays` requires ' +\n          '`mediaBudget.onPlayConsumed`. The SDK persists nothing, so without it the count lives ' +\n          'only in this mount: a refresh silently restores the full budget, and a paper that ' +\n          'grants unlimited plays while showing \"2 plays remaining\" is indistinguishable — to the ' +\n          'learner and to an appeal — from one that works. Budgeted media: ' +\n          `${[...new Set(budgetedMedia.map((m) => m.key))].join(', ')}.`,\n      );\n    }\n    const resuming =\n      (responses !== undefined && Object.keys(responses).length > 0) ||\n      (submittedSlotIds !== undefined && submittedSlotIds.length > 0);\n    if (resuming && mediaBudget.plays === undefined) {\n      throw new Error(\n        'ActivitySequence: this is a resumed attempt (`responses`/`submittedSlotIds` were ' +\n          'supplied) but `mediaBudget.plays` is absent. A resume that omits the ledger hands the ' +\n          'learner a fresh budget at exactly the moment it matters. Pass ' +\n          '`restoreMediaPlayLedger(plan, stored).entries`, or `{}` to state explicitly that ' +\n          'nothing was spent.',\n      );\n    }\n  }\n\n  // One recording must not carry two budgets, in any mode — six questions each\n  // holding the same clip at maxPlays 2 is twelve plays of one recording.\n  const keysByUrl = new Map<string, Set<string>>();\n  for (const { key, url } of budgetedMedia) {\n    const keys = keysByUrl.get(url) ?? new Set<string>();\n    keys.add(key);\n    keysByUrl.set(url, keys);\n  }\n  for (const [url, keys] of keysByUrl) {\n    if (keys.size > 1) {\n      throw new Error(\n        `ActivitySequence: media ${JSON.stringify(url)} is budgeted under ${keys.size} separate ` +\n          `keys (${[...keys].join(', ')}), so one recording grants ${keys.size} × maxPlays. Put ` +\n          \"the questions that share a recording in an item group — a group's stimulus is one \" +\n          'recording with one budget.',\n      );\n    }\n  }\n\n  /** The per-media binding handed to a component or to the stimulus panel. */\n  const bindingFor = (\n    key: string,\n    slot: { slotId: string; index: number; activity: { id: string } },\n  ): MediaBudgetBinding | undefined => {\n    if (mediaBudget === undefined) {\n      return undefined;\n    }\n    const entry =\n      mediaSeedsApply && mediaPlays !== undefined && Object.hasOwn(mediaPlays, key)\n        ? mediaPlays[key]\n        : undefined;\n    return {\n      key,\n      slotId: slot.slotId,\n      index: slot.index,\n      activityId: slot.activity.id,\n      ...(entry !== undefined ? { entry } : {}),\n      ...(mediaBudget.enforced !== undefined ? { enforced: mediaBudget.enforced } : {}),\n      ...(mediaBudget.onPlayConsumed !== undefined\n        ? { onPlayConsumed: mediaBudget.onPlayConsumed }\n        : {}),\n      ...(mediaBudget.onPlayRefunded !== undefined\n        ? { onPlayRefunded: mediaBudget.onPlayRefunded }\n        : {}),\n      ...(mediaBudget.onPosition !== undefined ? { onPosition: mediaBudget.onPosition } : {}),\n      ...(mediaBudget.strings !== undefined ? { strings: mediaBudget.strings } : {}),\n    };\n  };\n\n  /**\n   * The per-slot recording binding handed to a read-aloud, modelled on\n   * `bindingFor`: the sequence-level methods are called with the slot they\n   * belong to, and `assess` / `playbackUrl` are copied only when the consumer\n   * supplied them — a binding carrying `assess: undefined` is a binding the\n   * component would try to call.\n   *\n   * It watches nothing. The pager used to watch the promises it handed out to\n   * decide when a set was finished, and a promise knows nothing of the take\n   * that asked for it: a late failure from a paper no longer on screen landed\n   * in a new paper that reused the slot's ids, as a blank. What a take came to\n   * is reported by the component, numbered by take, through the slot's channel\n   * — see `record` and `reportIfFinished`.\n   *\n   * A consumer's own renderer is handed no binding.\n   */\n  const recordingBindingFor = (slot: {\n    slotId: string;\n    index: number;\n    activity: { id: string };\n  }): RecordingBinding | undefined => {\n    if (recordingBinding === undefined) {\n      return undefined;\n    }\n    const at: SequenceRecordingSlot = {\n      slotId: slot.slotId,\n      index: slot.index,\n      activityId: slot.activity.id,\n    };\n    const { assess, playbackUrl } = recordingBinding;\n    // Called on the binding, so a consumer's binding written as a class keeps\n    // its `this`.\n    return {\n      upload: (take) => recordingBinding.upload(take, at),\n      ...(assess !== undefined\n        ? { assess: (ref: RecordingRef) => assess.call(recordingBinding, ref, at) }\n        : {}),\n      ...(playbackUrl !== undefined\n        ? { playbackUrl: (ref: RecordingRef) => playbackUrl.call(recordingBinding, ref, at) }\n        : {}),\n    };\n  };\n\n  const forwarded = {\n    ...(onInteraction ? { onInteraction } : {}),\n    renderMode,\n    ...(sanitizeHtml ? { sanitizeHtml } : {}),\n    ...(strings !== undefined ? { strings } : {}),\n    ...(theme ? { theme } : {}),\n    ...(locale ? { locale } : {}),\n    ...(disabled ? { disabled } : {}),\n  };\n\n  const renderSlot = (slot: SequenceSlot<RenderableActivity>): React.JSX.Element => {\n    const activity = slot.activity;\n    const { slotId, index: slotIndex } = slot;\n    const activityId = activity.id;\n    const restored =\n      seedsApply && responses !== undefined && Object.hasOwn(responses, slotId)\n        ? responses[slotId]\n        : undefined;\n    const slotOutcome =\n      outcomes !== undefined && Object.hasOwn(outcomes, slotId) ? outcomes[slotId] : undefined;\n    const slotBinding = bindingFor(slotMediaKey(slotId), slot);\n    // Whether this slot's answers are numbered by take — see `record`.\n    const takesAnswers = renderMode === 'practice' && activity.type === 'read-aloud';\n    const childProps = {\n      // `defaultValue`, not `value`: the learner must be able to keep editing\n      // a restored answer. A controlled `value` would freeze it unless the\n      // consumer also threaded state back, which is not what resume means.\n      ...(restored !== undefined ? { defaultValue: restored } : {}),\n      ...(seedsApply && submitted.has(slotId) ? { defaultSubmitted: true } : {}),\n      ...(slotOutcome !== undefined ? { outcome: slotOutcome } : {}),\n      onComplete: (result: ActivityResult) =>\n        record(\n          { kind: 'scored', index: slotIndex, slotId, activityId, result },\n          setGeneration,\n          // The take the grade is for: stamped by `<ReadAloud>`, and for a\n          // consumer's renderer, which cannot stamp one, the slot's latest.\n          takesAnswers ? (takeOf(result) ?? takesRef.current.get(slotIndex)?.take) : undefined,\n        ),\n      onSubmit: (response: LearnerResponse) => {\n        // A submit through a callback handed out for an earlier set is a\n        // consumer renderer's late one, for a question no longer on screen: the\n        // host would file it against whatever slot reuses these ids now.\n        if (setGeneration !== setGenerationRef.current) {\n          return;\n        }\n        onSubmit?.(response, { slotId, index: slotIndex, activityId });\n        // Written responses are excluded in every mode because they report\n        // something richer through `onSubmitted` a moment later, and the first\n        // outcome wins.\n        if (activity.type === 'written-response') {\n          return;\n        }\n        // Outside `practice` the components do not grade, so a raw response is\n        // the ONLY outcome this slot will ever produce — record it, or the set\n        // could never complete and `onFinished` would be dead in exam mode.\n        if (renderMode !== 'practice') {\n          record(\n            { kind: 'responded', index: slotIndex, slotId, activityId, response },\n            setGeneration,\n          );\n          return;\n        }\n        // A `practice` read-aloud is the one type that can submit and then\n        // produce no score: an unscorable take, an assessor that failed, or a\n        // binding that stores without judging all end the attempt with nothing\n        // to grade, and `onComplete` fires only on a grade. Recorded for its\n        // take, so the grade that may still arrive for that take replaces it —\n        // and a take recorded again replaces the one before, grade and all.\n        if (takesAnswers) {\n          record(\n            { kind: 'responded', index: slotIndex, slotId, activityId, response },\n            setGeneration,\n            takeOf(response) ?? mintTake(),\n          );\n        }\n      },\n      ...forwarded,\n      ...(slotBinding !== undefined ? { mediaBudget: slotBinding } : {}),\n    };\n\n    const CustomRenderer = renderers?.[activity.type];\n    if (CustomRenderer) {\n      return <CustomRenderer data={activity} {...childProps} />;\n    }\n    if (activity.type === 'multiple-choice') {\n      return (\n        <MultipleChoice\n          data={activity}\n          // The sequence seed reaches the OPTION shuffle too. Without it a\n          // resumed or reviewed item invented a fresh per-mount order, so the\n          // learner saw their answers against a different arrangement than the\n          // one they sat — the exact reproducibility the attempt id is for.\n          {...(shuffleSeed !== undefined ? { shuffleSeed } : {})}\n          {...childProps}\n        />\n      );\n    }\n    if (activity.type === 'fill-in-the-blanks') {\n      return <FillInTheBlanks data={activity} {...childProps} />;\n    }\n    if (activity.type === 'gap-select') {\n      return (\n        <GapSelect\n          data={activity}\n          // The sequence seed reaches the per-gap choice shuffle too, for the\n          // same reason it reaches MultipleChoice's options: a resumed or\n          // reviewed item that dealt a fresh order would show the learner\n          // their answers against an arrangement they never sat.\n          {...(shuffleSeed !== undefined ? { shuffleSeed } : {})}\n          {...childProps}\n        />\n      );\n    }\n    if (activity.type === 'dictation') {\n      // Nothing to seed: a dictation shuffles nothing. Outside `practice` its\n      // raw response is recorded through `onSubmit` above, like MC/FIB/GS.\n      return <Dictation data={activity} {...childProps} />;\n    }\n    if (activity.type === 'read-aloud') {\n      const slotRecordingBinding = recordingBindingFor(slot);\n      const slotAssessment =\n        assessments !== undefined && Object.hasOwn(assessments, slotId)\n          ? assessments[slotId]\n          : undefined;\n      return (\n        <ReadAloud\n          data={activity}\n          // The whole bag, nothing subtracted — unlike the written-response\n          // branch below, which drops `onComplete` because it never grades. A\n          // read-aloud needs it in `practice`, where a returned grade is a\n          // score like any other, and simply never calls it in `exam`.\n          {...childProps}\n          // No capture group here: the slot's pane hands it down through\n          // `SequenceSlotContext`, so it is no prop of the public component.\n          {...(slotRecordingBinding !== undefined\n            ? { recordingBinding: slotRecordingBinding }\n            : {})}\n          {...(slotAssessment !== undefined ? { assessment: slotAssessment } : {})}\n        />\n      );\n    }\n    if (activity.type === 'written-response') {\n      // Derived from the SAME bag the other two get, minus the one prop this\n      // component genuinely does not have. Listing the props by hand is what\n      // made this the branch left behind three separate times —\n      // `defaultSubmitted`, the redacted-in-`practice` guard and the media\n      // budget were each added to `childProps` and each silently missed here.\n      // Subtracting from the shared bag cannot forget a prop that is added to\n      // it; listing them can.\n      const { onComplete: _neverGrades, ...writtenResponseProps } = childProps;\n      return (\n        <WrittenResponse\n          data={activity}\n          {...writtenResponseProps}\n          onSubmitted={(submission) =>\n            record(\n              { kind: 'submitted', index: slotIndex, slotId, activityId, submission },\n              setGeneration,\n            )\n          }\n        />\n      );\n    }\n    return (\n      <div className=\"lk-seq-unsupported\" role=\"note\">\n        {s.unsupportedActivity}\n      </div>\n    );\n  };\n\n  const currentEntryKey = entryKeyOf(current);\n\n  return (\n    <div className=\"lk-seq\" lang={locale}>\n      <div className=\"lk-seq-progress\" aria-live=\"polite\" role=\"status\">\n        {s.questionProgress(index + 1, total)}\n      </div>\n\n      {/*\n        Each group's stimulus is mounted ONCE and only hidden while the current\n        question is outside its group. That — not re-rendering it per slot — is\n        what makes the passage the same DOM node throughout, and what lets a\n        recording keep its position between questions of one group.\n\n        It sits BESIDE the question region, not inside it. Inside, every\n        navigation dropped focus onto a container whose first content was the\n        whole passage: the region promised \"Question 3 of 5\" and then began\n        with the passage, keyboard users tabbed through the stimulus (audio\n        controls included) before reaching the question, and the passage was a\n        landmark nested inside another landmark. As a sibling it stays a\n        landmark the learner can jump back to, while focus lands on the\n        question that was actually navigated to.\n      */}\n      {stimulusMounts.map(({ entryKey, group, first, last }) => {\n        // `setKey` leads for the same reason it does on a slot pane: entry keys\n        // are short and repeat across papers, so a set change to a DIFFERENT\n        // paper that happens to reuse an entry key would not remount this\n        // panel — and a mount-only budget seed would leak into the next paper.\n        const firstSlot = slots[first];\n        const stimulusBinding =\n          firstSlot === undefined\n            ? undefined\n            : bindingFor(stimulusMediaKey(firstSlot.slotId), firstSlot);\n        return (\n          <SequencePane\n            className=\"lk-seq-stimulus\"\n            hidden={entryKey !== currentEntryKey}\n            key={`${setKey}::group-${entryKey}`}\n          >\n            <StimulusPanel\n              stimulus={group.stimulus}\n              range={{ first: first + 1, last: last + 1 }}\n              renderMode={renderMode}\n              {...(sanitizeHtml ? { sanitizeHtml } : {})}\n              {...(locale ? { locale } : {})}\n              {...(onInteraction ? { onInteraction } : {})}\n              {...(disabled ? { disabled } : {})}\n              {...(strings !== undefined ? { strings } : {})}\n              {...(stimulusBinding !== undefined ? { mediaBudget: stimulusBinding } : {})}\n            />\n          </SequencePane>\n        );\n      })}\n\n      <section\n        className=\"lk-seq-question\"\n        ref={regionRef}\n        tabIndex={-1}\n        aria-label={s.questionProgress(index + 1, total)}\n      >\n        {/*\n          Every slot stays MOUNTED; only the current one is visible. Rendering\n          just the current activity unmounted the others, so navigating back to\n          an answered question showed it blank and re-answerable — the learner\n          silently lost their answer and a second submit fired completion\n          again. `hidden` removes the inactive slots from the accessibility\n          tree and from tab order, so only the current question is reachable.\n        */}\n        {slots.map((slot) => {\n          // The slot id (authored position) plus the activity id: the same\n          // activity may legitimately fill two slots, and each must keep its\n          // own answer state; and a different activity in the same slot must\n          // remount rather than inherit the previous one's state.\n          //\n          // `setKey` leads, so a set change remounts every child. Without it a\n          // pure REORDER changed `setKey` — clearing the outcomes — while each\n          // child kept its key and therefore its `completed` state. Those\n          // slots could not be answered again and no outcome would ever refill\n          // them, so the sequence could never finish. A reset has to reset\n          // both halves or neither. A parent re-creating a structurally\n          // identical array leaves `setKey` untouched, so answers still\n          // survive that.\n          const slotKey = `${setKey}::slot-${slot.slotId}-${slot.activity.id}`;\n          return (\n            <SequencePane\n              className=\"lk-seq-slot\"\n              hidden={slot.index !== index}\n              // A channel for every slot, not just the ones that record: its\n              // capture group is empty until something joins it, and a pane\n              // that asked whether its activity records would have to know the\n              // type of a renderer the consumer supplied.\n              channel={channelFor(slot)}\n              key={slotKey}\n            >\n              {renderSlot(slot)}\n            </SequencePane>\n          );\n        })}\n      </section>\n\n      <div className=\"lk-seq-nav\">\n        <button\n          type=\"button\"\n          className=\"lk-seq-prev\"\n          onClick={() => go(index - 1)}\n          disabled={index === 0}\n        >\n          {s.previous}\n        </button>\n        <button\n          type=\"button\"\n          className=\"lk-seq-next\"\n          onClick={() => go(index + 1)}\n          disabled={index === total - 1}\n        >\n          {s.next}\n        </button>\n      </div>\n    </div>\n  );\n}\n"]}