@intellectif/lk-react 18.0.0 → 19.0.0

package/dist/{strings-PCYKWCwd.d.ts → types-BY-4S5Rd.d.ts}

@@ -1,6 +1,6 @@
-import { SpeechAssessment, GradeRecord, ReadAloudData, RecordingRef, LearnerResponse, ActivityData, ActivityResult, ItemOutcome, MediaPlayLedgerEntry, MediaPlayClaim, MediaPlayGrant, InteractionEvent, ThemeTokens, RedactedActivityData, ItemGroup, SequenceEntry, ReadAloudDimension, ReadAloudWordState, Stimulus } from '@intellectif/lk-core';
+import { ReadAloudDimension, ReadAloudWordState, Stimulus, SpeechAssessment, GradeRecord, ReadAloudData, RecordingRef, LearnerResponse, ActivityData, ActivityResult, ItemOutcome, MediaPlayLedgerEntry, MediaPlayClaim, MediaPlayGrant, InteractionEvent, ThemeTokens, RedactedActivityData, ItemGroup, SequenceEntry } from '@intellectif/lk-core';
 import { LearnerAi } from './ai/LkAiProvider.js';
-import { R as RecordedTake, S as SpeechRecorderError } from './machine-CuwKqWXC.js';
+import { S as SpeechRecorderError, R as RecordedTake } from './machine-CuwKqWXC.js';
 
 /** The size captions are drawn at. */
 type CaptionSize = 'small' | 'medium' | 'large';
@@ -39,861 +39,861 @@ interface VideoPreferences {
 type VideoShortcutAction = 'play-pause' | 'jump-10' | 'jump-5' | 'jump-1' | 'frame' | 'speed' | 'percent' | 'start-end' | 'chapter' | 'mute' | 'captions' | 'secondary-captions' | 'transcript' | 'picture-in-picture' | 'fullscreen' | 'shortcut-list';
 
 /**
- * What an application's assessor came back with.
+ * Every string the SDK's own chrome renders.
  *
- * `code` is a plain `string` and not `SpeechUnscorableCode`: an application's
- * own assessor may refuse a take for a reason the SDK has no name for, and a
- * narrower type would make it unreportable. This component classifies the two
- * codes that mean "nothing was heard" and treats every other one the same way.
- */
-type ReadAloudAssessResult = {
-    status: 'graded';
-    assessment: SpeechAssessment;
-    grade: GradeRecord;
-} | {
-    status: 'unscorable';
-    code: string;
-    assessment?: SpeechAssessment;
-} | {
-    status: 'failed';
-    retryable: boolean;
-};
-/**
- * How a take reaches the application, and how a judgement comes back.
+ * Until 0.8.1 these were literals, and `locale` set only the `lang` attribute —
+ * so a learner sitting a Spanish paper read a Spanish passage inside an English
+ * scaffold, and "No plays remaining" on a listening exam was untranslatable.
+ * This is the whole surface, in one place, so a consumer can replace it.
  *
- * Named `recordingBinding` rather than `recording` because both
- * `ReadAloudData.recording` (the bounds) and `ReadAloudLearnerResponse.recording`
- * (the stored take) already exist: the plain name would read as one of those.
+ * **Interpolation and plurals are functions, not format strings.** A message
+ * like `"Question {n} of {total}"` needs a parser, and a parser needs plural
+ * rules for every locale the SDK does not know. A function hands both problems
+ * to the consumer, who has `Intl.PluralRules` and knows their own language:
+ *
+ * ```ts
+ * questionProgress: (index, total) => `Pregunta ${index} de ${total}`,
+ * wordCount: (n) => `${n} ${n === 1 ? 'palabra' : 'palabras'}`,
+ * ```
+ *
+ * It also lets a translation reorder its arguments, which a positional token
+ * cannot, and TypeScript checks the arity. No parser, no message catalogue
+ * format, no runtime dependency.
+ *
+ * **What is deliberately NOT here: thrown errors.** Every `throw` in this
+ * package is addressed to the developer who wired the component up, not to the
+ * learner. Translating them would make them unsearchable and would put the one
+ * audience who can act on them behind a translation. They stay English.
  */
-interface RecordingBinding {
+interface LkStrings {
+    /** Multiple Choice submit button, and Written Response. */
+    submit: string;
+    /** Fill-in-the-Blanks in `practice`: the learner is checking their own work. */
+    checkAnswers: string;
+    /** Fill-in-the-Blanks in `exam`: nothing is checked on the client. */
+    submitAnswers: string;
     /**
-     * Puts the take in your storage and returns its key. **Required** outside
-     * `review`: without it a learner can speak into a control that submits
-     * nothing. Settle it — a promise that never does leaves the submit pending
-     * for ever.
+     * The scored result, read by a screen reader on submit.
+     *
+     * `percent` is already rounded to a whole number. The authored overall
+     * feedback is appended SEPARATELY by the component, so a translation of this
+     * sentence never has to carry the author's words — the two were previously
+     * concatenated into one literal, which made the score sentence untranslatable
+     * without also touching authored content.
      */
-    upload(take: RecordedTake): Promise<RecordingRef>;
+    scoreAnnouncement: (percent: number, passed: boolean) => string;
+    /** Prefix announced on submit, before the score sentence. */
+    answerSubmitted: string;
+    /** An answer submitted for grading that has none yet. Never rendered as 0%. */
+    notGradedYet: string;
+    /** An outcome that carries no grade and never will. */
+    noGradeAvailable: string;
+    showFeedback: string;
+    hideFeedback: string;
+    /** Accessible name of a blank's input. `ordinal` is 1-based. */
+    blankLabel: (ordinal: number) => string;
+    /** Accessible name of the selector for one gap in a Gap Select passage. */
+    gapLabel: (ordinal: number) => string;
     /**
-     * Judges the stored take. `practice` only — an exam never assesses on the
-     * client. Optional: a binding without it records, uploads and submits, and
-     * the feedback is replaced by a notice.
+     * The empty first entry of a gap's selector — how a learner leaves a gap
+     * alone, and how they take an answer back. Never a real choice.
      */
-    assess?(ref: RecordingRef): Promise<ReadAloudAssessResult>;
-    /** A playable link to a stored take. `review` only. */
-    playbackUrl?(ref: RecordingRef): Promise<string>;
-}
-interface ReadAloudProps extends ActivityProps<ReadAloudData> {
-    /** How a take is stored and judged. See {@link RecordingBinding}. */
-    recordingBinding?: RecordingBinding;
+    gapPlaceholder: string;
+    showHint: string;
+    hideHint: string;
     /**
-     * The evidence behind a stored grade, for `review`. Without it a graded
-     * outcome still shows its marks, rebuilt from `outcome.grade.details`; with
-     * neither, the score is shown and no marks are.
+     * Announced when an essay is handed in. Distinct from {@link LkStrings.awaitingGrade},
+     * which is the `review`-mode state of a submission made earlier: this one
+     * confirms the act, and is the only thing a learner hears at the moment they
+     * commit work that nothing on the client will grade.
      */
-    assessment?: SpeechAssessment;
+    responseSubmitted: string;
+    /** Live word counter. Needs the count for languages whose plural rules differ. */
+    wordCount: (count: number) => string;
+    /** The authored bounds, e.g. "50–200 words". `min` is 0 when unbounded below. */
+    wordBounds: (min: number, max: number) => string;
+    /** A rubric criterion the grader marked not applicable. */
+    notApplicable: string;
+    /** A returned grade flagged for a human to look at — learner-visible by design. */
+    awaitingHumanReview: string;
+    /** Submitted, no grade back yet. */
+    awaitingGrade: string;
+    /** The grader could not produce a grade. */
+    couldNotBeGraded: string;
+    previous: string;
+    next: string;
+    /** Progress label, also the question region's accessible name. `index` is 1-based. */
+    questionProgress: (index: number, total: number) => string;
+    /** Shown when no renderer is registered for an activity type. */
+    unsupportedActivity: string;
+    /** Accessible name of the box the learner types the recording into. */
+    dictationInputLabel: string;
+    /** Accessible name of the group holding the recording. */
+    dictationRecording: string;
+    /** Accessible name of the group holding the slower recording, and its default `alt`. */
+    dictationSlowRecording: string;
+    /** The progressive-hint button, with how many transcript words are shown so far. */
+    dictationRevealNextWord: (revealed: number, total: number) => string;
+    /** Hides every revealed hint word again. */
+    dictationResetHints: string;
+    /** The solution toggle: shows the transcript after the attempt is marked. */
+    showSolution: string;
+    hideSolution: string;
+    /** Accessible name of the revealed transcript. */
+    dictationSolutionLabel: string;
+    /** Accessible name of the word-by-word marked result. */
+    dictationMarksLabel: string;
+    /** Tells the learner the marks compare the normalised text, not what they typed. */
+    dictationDiffNote: string;
     /**
-     * Confidence above which a break note is shown, 0..1, forwarded to
-     * {@link PronunciationFeedback}. No default — see its own prop.
+     * The four sentences a screen reader hears for a marked word — the only
+     * channel the marks have for assistive technology; the glyphs and the
+     * character diff are decoration.
      */
-    breakThreshold?: number;
-    /** The same, for the monotone note. */
-    monotoneThreshold?: number;
+    dictationWordCorrect: (word: string) => string;
+    dictationWordWrong: (word: string, expected: string) => string;
+    dictationWordMissing: (expected: string) => string;
+    dictationWordExtra: (word: string) => string;
+    /** The legend rows; the character-level marks reuse the same four. */
+    dictationLegendCorrect: string;
+    dictationLegendWrong: string;
+    dictationLegendMissing: string;
+    dictationLegendExtra: string;
+    /** Marked result of an attempt with no words in it once punctuation and spacing are ignored, an empty one included. */
+    dictationNothingTyped: string;
     /**
-     * The URL of a self-hosted copy of `CAPTURE_PROCESSOR_SOURCE`, handed to the
-     * recorder, for a Content-Security-Policy whose `script-src` does not allow
-     * `blob:`. Without it the capture module is loaded from a `blob:` URL, and a
-     * policy that refuses one sends every take through the deprecated
-     * main-thread `ScriptProcessorNode` — a take that still records, so nothing
-     * says so. See `useSpeechRecorder`'s option of the same name.
+     * Appended to the score announcement, e.g. "4 of 6 words correct." — a whole
+     * sentence, because authored feedback may follow it.
      */
-    workletUrl?: string;
+    dictationWordsSummary: (correct: number, total: number) => string;
+    /** Accessible name of the group holding the model recording. */
+    readAloudModelRecording: string;
+    /** Accessible name of the group holding the slower model recording, and its default `alt`. */
+    readAloudSlowRecording: string;
+    /** Starts a take. */
+    readAloudRecord: string;
+    /** Ends the take in progress. */
+    readAloudStop: string;
+    /** Throws the take away so the learner can start over. */
+    readAloudRerecord: string;
+    /** Accessible name of the player for the take the learner just made. */
+    readAloudYourRecording: string;
     /**
-     * Never called. A read-aloud answer is a key in your storage, and there is
-     * none until the take has been uploaded — so there is no intermediate
-     * response to report, and reporting the take itself would offer a host a
-     * recording it has nowhere to put. `onSubmit` carries the response, once.
+     * In place of the player for the learner's own take, and of the buttons that
+     * play one word of it, when the page refuses to play it — most often a
+     * Content-Security-Policy whose `media-src` does not allow `blob:`. Said
+     * rather than left as controls that do nothing when pressed.
      */
-    onChange?: (response: LearnerResponse) => void;
-}
-
-/**
- * How an activity is being presented. This is the single switch that decides
- * whether the component may grade, reveal, or submit — the three things a
- * summative exam must take away from the client.
- *
- * - `practice` (default, and the only behaviour before `renderMode` existed):
- *   the component owns the attempt. It
- *   scores locally on submit, reveals correctness and feedback, and calls
- *   `onComplete` with a full {@link ActivityResult}.
- * - `exam`: the component NEVER scores and NEVER reveals correctness. Submit
- *   emits the raw learner response through `onSubmit`; the server grades it.
- *   Safe to render redacted data, because nothing here needs the answer key.
- * - `review`: read-only. Renders the learner's submitted answer, and marks
- *   correctness only from an `outcome` the caller supplies (which the server
- *   computed). Nothing is submittable.
- */
-type RenderMode = 'practice' | 'exam' | 'review';
-/**
- * Makes the answer-key-bearing parts of an activity optional, so a component
- * can render either full activity data OR a `redact()` projection with the
- * same props. Fields the SDK classifies `answer-key` become optional here;
- * a component in `exam` mode must not read them at all.
- */
-type Renderable<TData> = Omit<TData, 'scoringStrategy'> & {
-    scoringStrategy?: unknown;
-    /** Present on a `redact()` projection. */
-    redacted?: true;
-};
-/**
- * {@link Renderable} DISTRIBUTED over a union of activity types.
- *
- * This distinction is load-bearing, not cosmetic. `Renderable<T>` is built on
- * `Omit`, and `Omit` does not distribute: `Omit<A | B, K>` collapses to the
- * keys A and B have IN COMMON, so `Renderable<ActivityData>` is a single
- * object type carrying only the fields every activity shares. Narrowing it
- * dies with it — after `if (data.type === 'multiple-choice')` the compiler
- * still refuses `data.options`, because the union it would narrow to no
- * longer exists.
- *
- * The conditional below re-distributes, so `RenderableActivity` is a real
- * union of per-type renderables and `.type` narrows again. Anything that
- * accepts "some renderable activity, I don't know which" — a custom renderer,
- * a sequence entry — must use THIS, not `Renderable<ActivityData>`.
- */
-type RenderableActivity<TData extends ActivityData = ActivityData> = TData extends unknown ? Renderable<TData> : never;
-/**
- * Sanitiser for author-supplied rich text (`questionHtml`, `promptHtml`, and a
- * stimulus's `bodyHtml`). The SDK deliberately ships NO sanitiser — that would
- * add a dependency and, worse, a false promise. Rich text is rendered only when
- * you supply this function; without it the component falls back to the
- * plain-text field, which is always escaped. Fail-safe by construction: the SDK
- * never injects HTML it was not explicitly given a sanitiser for.
- *
- * `FillInTheBlanks.passageHtml` is the one exception, and is **never**
- * rendered: the passage hosts the answer inputs, so it cannot be split at the
- * `{{blank}}` placeholders without voiding the sanitiser. The plain `passage`
- * is always used, and passing `passageHtml` warns in development.
- */
-type HtmlSanitizer = (html: string) => string;
-/**
- * The prop contract shared by every activity component (Req 3.1). Defined
- * here (React-specific) rather than in lk-core, which is React-free.
- *
- * Controlled / uncontrolled follows the React convention: pass `value` +
- * `onChange` to own the learner's answer (restore an in-progress attempt,
- * autosave a delta, drive a review); pass `defaultValue` to seed an
- * uncontrolled component; pass neither to keep the pre-2.1.0 behaviour, where
- * the component owns the answer outright.
- */
-interface ActivityProps<TData extends ActivityData = ActivityData> {
-    /** Activity content. Accepts a `redact()` projection in `exam` mode. */
-    data: RenderableActivity<TData>;
+    readAloudPlaybackUnavailable: string;
     /**
-     * Called when the component scored the attempt itself. Only ever fires in
-     * `practice` mode — in `exam` mode the client does not grade, so there is
-     * no `ActivityResult` to give you; use `onSubmit`.
+     * Live progress while recording. Whole seconds, not a `m:ss` clock: a
+     * recording is bounded in seconds by the item, and a translation should not
+     * have to reimplement a clock to change the word around it.
+     *
+     * Shown on screen and hidden from assistive technology: it changes every
+     * second, and a screen reader that spoke each change would speak into the
+     * take being assessed. The two sentences below are what is announced instead.
      */
-    onComplete?: (result: ActivityResult) => void;
+    readAloudRecordingProgress: (seconds: number, maxSeconds: number) => string;
+    /** Announced once when a capture begins. */
+    readAloudRecordingStarted: string;
     /**
-     * Called on submit with the raw learner response and no grade. Fires in
-     * every mode, before `onComplete`, so an exam runner can persist the
-     * response and let the server score it.
+     * Announced once when a capture ends, by the learner or at its own bound.
+     * Carries the length because the progress counter is not announced: a take
+     * that reads back as "20 of 20 seconds" is one that stopped itself.
      */
-    onSubmit?: (response: LearnerResponse) => void;
-    /** Controlled value: the learner's current response. */
-    value?: LearnerResponse;
-    /** Initial response for an uncontrolled component (ignored when `value` is set). */
-    defaultValue?: LearnerResponse;
+    readAloudRecordingStopped: (seconds: number, maxSeconds: number) => string;
+    /** How many takes are left. Called with 0 as well, so the wording is one translation's. */
+    readAloudTakesRemaining: (remaining: number, max: number) => string;
+    /** `exam` only: hands the item in with no recording at all, deliberately. */
+    readAloudSubmitWithoutRecording: string;
+    /** Pending, while the take travels to the application's storage. */
+    readAloudUploading: string;
+    /** The take never reached storage, so nothing was submitted. */
+    readAloudUploadFailed: string;
+    /** Retries whichever step just failed. */
+    readAloudTryAgain: string;
+    /** Pending, while the assessor judges the take. */
+    readAloudAssessing: string;
+    /** The binding stores recordings but judges none, so there is no feedback to show. */
+    readAloudAssessmentUnavailable: string;
+    /** The assessor found no speech, or too little of it, in the take. */
+    readAloudNotHeard: string;
+    /** The assessor produced no grade for any other reason. The code itself is never shown. */
+    readAloudNotAssessed: string;
+    /** The assessment could not be run at all — a failure of the call, not of the reading. */
+    readAloudAssessmentFailed: string;
     /**
-     * Mount the component as already submitted — read at mount only, like any
-     * `default*` prop.
-     *
-     * Restoring an attempt without it reopens a question the learner had already
-     * submitted as answerable, so on a summative paper they can change and
-     * re-submit it. `AttemptState.submittedSlotIds` is what this consumes.
+     * What went wrong with the microphone or with the take. One function rather
+     * than five keys, so a translation keeps the five sentences together and the
+     * SDK keeps one name for the concept.
      */
-    defaultSubmitted?: boolean;
-    /** Fires on every change to the learner's response. Required for a controlled component. */
-    onChange?: (response: LearnerResponse) => void;
-    /** Presentation mode. Defaults to `practice`. */
-    renderMode?: RenderMode;
+    readAloudRecorderError: (reason: SpeechRecorderError) => string;
+    /** Accessible name of the whole feedback region. */
+    pronunciationFeedbackLabel: string;
+    /** Name of one scored dimension, as a learner reads it. */
+    pronunciationDimension: (dimension: ReadAloudDimension) => string;
+    /** A dimension or a word the engine did not measure. NEVER rendered as 0%. */
+    pronunciationNotAssessed: string;
+    /** Accessible name of the word-by-word marks. */
+    pronunciationWordsLabel: string;
+    /** One legend row per marking state — the same four states the marks carry. */
+    pronunciationLegend: (state: ReadAloudWordState) => string;
     /**
-     * Server-computed outcome, used by `review` mode to mark correctness
-     * without the client ever scoring. Ignored in other modes.
+     * The four sentences a screen reader hears for a marked word: the only
+     * channel the marks have for assistive technology, since the glyph and the
+     * decoration are both hidden from it.
      */
-    outcome?: ItemOutcome;
-    /** Renders author-supplied rich text when provided. See {@link HtmlSanitizer}. */
-    sanitizeHtml?: HtmlSanitizer;
+    pronunciationWordCorrect: (word: string) => string;
+    pronunciationWordMispronounced: (word: string) => string;
+    pronunciationWordOmitted: (word: string) => string;
+    pronunciationWordInserted: (word: string) => string;
+    /** Opens one word's syllables, sounds and timings. */
+    pronunciationWordDetails: (word: string) => string;
+    pronunciationSyllables: string;
+    pronunciationPhonemes: string;
+    /** A syllable the engine also spelled out, e.g. `('ˈhæ', 'ha')`. */
+    pronunciationSyllableSpelling: (syllable: string, grapheme: string) => string;
+    /** A sound the engine named no symbol for; `ordinal` is 1-based. */
+    pronunciationPhonemePosition: (ordinal: number) => string;
+    /** Introduces the sounds the engine thought it heard in a sound's place. */
+    pronunciationHeardAs: string;
+    /** Plays one word out of the learner's own take. */
+    pronunciationPlayWord: (word: string) => string;
+    pronunciationBreakUnexpected: string;
+    pronunciationBreakMissing: string;
+    /** Shown only past the caller's own monotone threshold; the SDK sets none. */
+    pronunciationMonotone: string;
+    /** Names the alphabet the phoneme symbols are written in. */
+    pronunciationIpaNote: string;
+    /** Jump buttons, e.g. "Back 10 seconds". */
+    videoBack: (seconds: number) => string;
+    videoForward: (seconds: number) => string;
+    /** The centre button once the video has ended. */
+    videoReplay: string;
+    /** The time readout flips between elapsed and remaining; these name what a press shows next. */
+    videoShowRemaining: string;
+    videoShowElapsed: string;
+    /** The captions button, named by what a press does. */
+    videoCaptionsShow: string;
+    videoCaptionsHide: string;
+    /** In the captions menu when a caption file could not be read. */
+    videoCaptionsFailed: string;
+    /** The same, for the second language: the first line keeps working. */
+    videoSecondaryCaptionsFailed: string;
+    /** A speed in the speed menu, e.g. "1.25×". */
+    videoSpeedValue: (rate: number) => string;
+    videoSettings: string;
+    videoCaptionLanguage: string;
+    /** The captions page's item, and page, for a second caption line under the first. */
+    videoSecondCaptionLanguage: string;
     /**
-     * Binds this activity's own `data.media` to a play budget the consumer
-     * persists. Usually supplied by `<ActivitySequence mediaBudget={…}>`; pass it
-     * yourself when rendering an activity standalone.
+     * The captions row of the settings menu when two languages show, from the
+     * tracks' own labels: "English + Español". A translation may order them as its
+     * language reads, but the first argument is always the upper line.
      */
-    mediaBudget?: MediaBudgetBinding;
-    /** Translations for the audio transport chrome. See {@link MediaTransportStrings}. */
-    mediaStrings?: Partial<MediaTransportStrings>;
+    videoCaptionPair: (primary: string, secondary: string) => string;
+    /** Announced when Shift + C finds no other language to show. */
+    videoNoSecondLanguage: string;
+    videoCaptionSize: string;
+    videoCaptionSizeValue: (size: CaptionSize) => string;
+    videoCaptionBackground: string;
+    videoKeyboardShortcuts: string;
+    videoShortcutList: string;
+    /** Closes the shortcut list. */
+    videoClose: string;
+    /** A setting's state in the settings menu. */
+    videoOn: string;
+    videoOff: string;
+    /** What each row of the shortcut list does. */
+    videoShortcut: (action: VideoShortcutAction) => string;
+    /** The button that opens the panel below the video, and its two tabs. */
+    videoPanel: string;
+    videoContents: string;
+    videoTranscript: string;
+    videoTranscriptSearch: string;
+    videoTranscriptNoMatch: string;
+    videoPictureInPicture: string;
+    videoFullscreen: string;
+    videoExitFullscreen: string;
     /**
-     * Overrides the SDK's chrome text for this activity, layered on whatever
-     * `LkIntlProvider` supplies. `mediaStrings` still works and is merged after
-     * this, so an existing 0.8.x call site keeps behaving as it did.
+     * Why the video will not play, by `MediaError.code` (1 aborted, 2 network,
+     * 3 decode, 4 source), with 0 for anything else.
      */
-    strings?: LkStringsOverride;
-    onInteraction?: (event: InteractionEvent) => void;
+    videoError: (code: number) => string;
+    videoTryAgain: string;
+    /** A quiz with no title of its own. */
+    videoQuiz: string;
+    /** Where the learner is inside a quiz, e.g. "Question 2 of 5". */
+    videoQuestionProgress: (index: number, total: number) => string;
+    /** A step of the quiz's step indicator, for assistive technology. */
+    videoQuestionStep: (index: number, answered: boolean) => string;
+    videoNextQuestion: string;
+    videoContinue: string;
+    videoSkipQuiz: string;
+    videoRewatch: string;
+    /** Exam mode, once a question is submitted: saved, not graded. */
+    videoAnswerSaved: string;
+    /** The end card, while an answer is still being stored or graded: why Finish waits. */
+    videoAnswerPending: string;
+    videoRequired: string;
+    /** A quiz's progress in the contents panel and on the end screen. */
+    videoQuizProgress: (answered: number, total: number) => string;
+    /** Announced when a quiz opens. */
+    videoQuizOpened: (time: string, questions: number) => string;
+    /** Announced when a seek stopped at a required quiz. */
+    videoHeldAtQuiz: (time: string) => string;
+    /** Announced when a seek stopped at the furthest point reached. */
+    videoHeldAhead: string;
+    videoEnded: string;
+    /** Practice end screen: questions answered, and the score. */
+    videoEndScore: (answered: number, total: number, percent: number) => string;
+    /** Exam end screen: questions answered, no score. */
+    videoEndAnswered: (answered: number, total: number) => string;
+    videoWatchAgain: string;
+    videoFinish: string;
     /**
-     * The host's AI ports for this activity — an explanation after grading, hints
-     * before submit — overriding `LkAiProvider`'s. Leave a port out to switch
-     * that help off. Nothing AI appears in `exam`, and an item whose author
-     * switched a feature off (`data.ai`) never shows it. See {@link LearnerAi}.
+     * `<ActivityPreview>`, in place of a draft that still has something missing.
+     * Author-facing, not learner-facing — but an editor is translated too.
      */
-    ai?: LearnerAi;
-    /** Per-instance token overrides, applied as inline CSS vars on the root. */
-    theme?: Partial<ThemeTokens>;
+    previewIncomplete: string;
+    /** `<ActivityPreview>`, in place of a draft with something wrong in it. */
+    previewInvalid: string;
     /**
-     * BCP 47 tag stamped as `lang` on this component's root. This is the
-     * INTERFACE language — the SDK's own chrome renders inside that element — so
-     * it should carry the same value you give `<LkIntlProvider locale>`. Passing
-     * a different one re-declares the language of every SDK string in this
-     * subtree without changing the words.
-     *
-     * It is NOT `data.locale`, which labels xAPI statements — and, on a
-     * dictation, places the dictation's own words: `<Dictation>` puts it, and
-     * the direction it names, on its title, hints, marks and solution. Other
-     * authored content in another language belongs on `stimulus.locale`, which
-     * `<StimulusPanel>` puts on the passage alone.
+     * Accessible name of a provider iframe whose author supplied no `alt`.
+     * `MediaSchema` requires `alt` on an embed, so validated content never
+     * reaches this — but `validateActivity` is opt-in, and a screen-reader
+     * learner meeting an unvalidated one should not meet it in English.
      */
-    locale?: string;
-    disabled?: boolean;
-}
-/**
- * Bridges a server-produced `redact()` projection into the `data` prop.
- *
- * `RedactedActivityData` is deliberately index-signature typed in lk-core — it
- * proves a payload is learner-safe, not what shape it has — so TypeScript
- * cannot know it still carries the public fields a renderer needs. This is the
- * SDK's single, documented crossing of that gap, so an exam runner does not
- * have to write `as unknown as` at every call site:
- *
- * ```tsx
- * <MultipleChoice
- *   data={asRenderable<MultipleChoiceData>(redactedFromServer)}
- *   renderMode="exam"
- *   onSubmit={persist}
- * />
- * ```
- *
- * Safe because `exam` mode reads only public fields; the answer-key fields the
- * type claims are exactly the ones the component is forbidden to touch there.
- *
- * Per-type redacted interfaces (`RedactedMultipleChoiceData`, …) ship from
- * lk-core since 0.6.0, but they are not yet *assignable* to `data`:
- * {@link Renderable} widens `scoringStrategy` and leaves nested answer-key
- * fields (`options[].isCorrect`, `blanks[].acceptedAnswers`) required, so a
- * real redacted payload still needs this bridge. Closing that gap is tracked
- * in the roadmap.
- */
-declare function asRenderable<TData extends ActivityData>(redacted: RedactedActivityData): Renderable<TData>;
+    embeddedMedia: string;
+    /**
+     * Accessible name of the stimulus region when the author gave it no title.
+     * Keyed by `Stimulus['kind']`, because "Recording" and "Passage" do not share
+     * a gender or an article in every language.
+     */
+    stimulusKind: Record<Stimulus['kind'], string>;
+    /**
+     * How far the material carries, e.g. "Questions 3–8". Called with equal
+     * `first` and `last` for a single question, so a translation can choose its
+     * own singular rather than receive a pre-pluralised English one.
+     */
+    stimulusRange: (first: number, last: number) => string;
+    /** Production fallback when an activity throws during render. */
+    activityFailed: string;
+    /** The same, when the activity's title is known. */
+    activityFailedNamed: (title: string) => string;
+    /** Production fallback when the activity has no title to name. */
+    activityFailedUnnamed: string;
+    /** The button that asks for an explanation of a graded answer. */
+    aiExplain: string;
+    /** The same button while the explanation is being written. */
+    aiExplaining: string;
+    /** The heading over an explanation, and its accessible name. */
+    aiExplanation: string;
+    /** When no explanation can be shown: the port failed, or its answer was refused. */
+    aiExplanationUnavailable: string;
+    /** The button that asks for a hint. */
+    aiHint: string;
+    /** The same button while the hint is being written. */
+    aiHintLoading: string;
+    /** The label before each hint. */
+    aiHintNumber: (hintNumber: number) => string;
+    /** The accessible name of the list of hints. */
+    aiHints: string;
+    /** When no hint can be shown: the port failed, or its hint gave the answer away. */
+    aiHintUnavailable: string;
+    /** In place of the hint button once every hint has been used. */
+    aiNoMoreHints: string;
+    /** Beneath every AI text: who wrote it. */
+    aiNotice: string;
+    /**
+     * The listening-paper transport. Shipped in 0.8.0 as its own `mediaStrings`
+     * prop, which still works — this is the same shape, reachable from the one
+     * provider so a consumer does not wire two mechanisms.
+     */
+    media: MediaTransportStrings;
+}
+/** A partial override, nested one level for {@link LkStrings.media}. */
+type LkStringsOverride = Partial<Omit<LkStrings, 'media' | 'stimulusKind'>> & {
+    media?: Partial<MediaTransportStrings>;
+    stimulusKind?: Partial<Record<Stimulus['kind'], string>>;
+};
 /**
- * The same bridge as {@link asRenderable}, for a whole sequence: activities
- * and item groups as a server hands them over, ready for `<ActivitySequence>`.
- *
- * Needed for the same reason and no other. `redactItemGroup` returns
- * `ItemGroup<RedactedActivityData>`, and `RedactedActivityData` is an
- * index-signature type whose fields are all `unknown` — so its `question` is
- * not a `string` and it satisfies no per-type renderable, however the prop is
- * widened. Widening alone cannot fix this; a crossing point is required, and
- * having exactly one keeps `as unknown as` out of consumer code.
- *
- * ```tsx
- * const entries = await fetchExam();            // redacted, server-side
- * <ActivitySequence
- *   activities={asRenderableSequence(entries)}
- *   renderMode="exam"                           // REQUIRED: see below
- *   shuffleSeed={attemptId}
- *   onSubmit={persist}
- * />
- * ```
- *
- * Pass `renderMode="exam"` (or `"review"`). Redacted data has no answer key, and
- * almost every built-in activity throws at render in the default `practice`
- * mode rather than fail later: `<MultipleChoice>`, `<FillInTheBlanks>`,
- * `<GapSelect>` and `<Dictation>` because they grade locally, and
- * `<WrittenResponse>` because `practice` still runs its local submit path and
- * emits a practice-mode xAPI statement.
- *
- * `<ReadAloud>` is the exception and renders a projection in every mode: a
- * read-aloud item has no answer key to withhold, so `redact()` removes only the
- * authored feedback and leaves the reading, its language and its bounds — which
- * is everything the component puts on screen. It grades nothing locally either;
- * the grade comes back from whatever the application asked to judge the take.
+ * English defaults, byte-identical to what every component rendered before the
+ * strings surface existed. Supplying no override changes nothing on screen.
  */
-declare function asRenderableSequence(entries: readonly (RedactedActivityData | RedactedItemGroupData)[]): readonly SequenceEntry<RenderableActivity>[];
-/** Structural shape of a `redactItemGroup()` projection, as it arrives from a server. */
-type RedactedItemGroupData = ItemGroup<RedactedActivityData> & {
-    redacted: true;
-};
+declare const DEFAULT_STRINGS: LkStrings;
 /**
- * Every word the SDK's audio transport renders.
- *
- * Words, not characters: the `m:ss / m:ss` clock is digits and punctuation and
- * is formatted by the component, because it reads identically in every locale
- * this SDK targets. The scrubber's SPOKEN value does have a word in it and does
- * have a key ({@link MediaTransportStrings.timeValue}).
+ * Layers an override onto a base dictionary.
  *
- * Supply them to translate it. These are the highest-stakes strings on a
- * listening paper — "No plays remaining" decides whether a learner believes
- * they may try again — so shipping them as untranslatable English inside a
- * Spanish panel was not acceptable. Supplying any of them also sets `lang` on
- * the transport chrome, so a screen reader does not read the SDK's own words
- * with the passage's phonetics.
+ * Two levels deep and no further, because the shape is two levels deep. A
+ * generic deep merge would silently accept a nested object where a function
+ * belongs and fail at render instead of at the call site.
  */
-interface MediaTransportStrings {
-    play: string;
-    pause: string;
-    preparing: string;
-    mute: string;
-    unmute: string;
-    volume: string;
-    speed: string;
-    seek: string;
-    /**
-     * Spoken value of the scrubber, e.g. `('1:05', '4:30') => '1:05 of 4:30'`.
-     * Takes ALREADY-FORMATTED `m:ss` strings: a translation should not have to
-     * reimplement the clock to change the word between them.
-     */
-    timeValue: (elapsed: string, duration: string) => string;
-    /** e.g. `(1, 2) => '1 of 2 plays remaining'`. */
-    playsRemaining: (remaining: number, max: number) => string;
-    noPlaysRemaining: string;
-    /** Shown before the LAST play is spent, so a stray press cannot cost it. */
-    lastPlayConfirm: string;
-    lastPlayStart: string;
-    lastPlayCancel: string;
-    seekBlocked: string;
-    rateBlocked: string;
-    playFailed: string;
-}
+declare function mergeStrings(base: LkStrings, override?: LkStringsOverride): LkStrings;
+
 /**
- * Binds ONE media block to a play budget the consumer persists.
+ * What an application's assessor came back with.
  *
- * The SDK refuses a play; it does not remember one. Everything durable here is
- * the consuming application's — see {@link SequenceMediaBudget.onPlayConsumed}.
+ * `code` is a plain `string` and not `SpeechUnscorableCode`: an application's
+ * own assessor may refuse a take for a reason the SDK has no name for, and a
+ * narrower type would make it unreportable. This component classifies the two
+ * codes that mean "nothing was heard" and treats every other one the same way.
  */
-interface MediaBudgetBinding {
-    /** From `slotMediaKey(slotId)` / `stimulusMediaKey(slotId)` in lk-core. */
-    key: string;
-    /** Plays already spent, and where playback stood. Read at mount only. */
-    entry?: MediaPlayLedgerEntry;
-    /** Defaults to `renderMode !== 'review'`. An explicit boolean wins either way. */
-    enforced?: boolean;
-    /** Slot context stamped onto the claim and the interaction event. */
-    slotId: string;
-    index: number;
-    activityId?: string;
-    onPlayConsumed?: (claim: MediaPlayClaim) => undefined | Promise<MediaPlayGrant | undefined>;
-    onPlayRefunded?: (claim: MediaPlayClaim) => void;
-    onPosition?: (key: string, seconds: number) => void;
-    /** Translations for the transport chrome. */
-    strings?: Partial<MediaTransportStrings>;
-}
+type ReadAloudAssessResult = {
+    status: 'graded';
+    assessment: SpeechAssessment;
+    grade: GradeRecord;
+} | {
+    status: 'unscorable';
+    code: string;
+    assessment?: SpeechAssessment;
+} | {
+    status: 'failed';
+    retryable: boolean;
+};
 /**
- * The pager-level half of a play budget. One prop, because it is one concept.
+ * How a take reaches the application, and how a judgement comes back.
+ *
+ * Named `recordingBinding` rather than `recording` because both
+ * `ReadAloudData.recording` (the bounds) and `ReadAloudLearnerResponse.recording`
+ * (the stored take) already exist: the plain name would read as one of those.
  */
-interface SequenceMediaBudget {
+interface RecordingBinding {
     /**
-     * `MediaPlayLedger.entries` goes straight in. An absent key means nothing
-     * spent. Read at mount, like `responses`.
+     * Puts the take in your storage and returns its key. **Required** outside
+     * `review`: without it a learner can speak into a control that submits
+     * nothing. Settle it — a promise that never does leaves the submit pending
+     * for ever.
      */
-    plays?: Readonly<Record<string, MediaPlayLedgerEntry>>;
+    upload(take: RecordedTake): Promise<RecordingRef>;
     /**
-     * Re-seed token. Change this string and the budgets re-seed from `plays`
-     * WITHOUT remounting the pager — the invigilator path ("the audio never
-     * started, give her the play back") that would otherwise cost the learner
-     * their focus, their scroll position and an unsaved answer.
+     * Judges the stored take. `practice` only — an exam never assesses on the
+     * client. Optional: a binding without it records, uploads and submits, and
+     * the feedback is replaced by a notice.
      */
-    resumeKey?: string;
-    /** Explicit override of the default (`renderMode !== 'review'`). */
-    enforced?: boolean;
+    assess?(ref: RecordingRef): Promise<ReadAloudAssessResult>;
+    /** A playable link to a stored take. `review` only. */
+    playbackUrl?(ref: RecordingRef): Promise<string>;
+}
+interface ReadAloudProps extends ActivityProps<ReadAloudData> {
+    /** How a take is stored and judged. See {@link RecordingBinding}. */
+    recordingBinding?: RecordingBinding;
     /**
-     * Called the instant a play is claimed, BEFORE any audio is audible.
-     *
-     * Two tiers, chosen by what you return:
-     *
-     * - **Return nothing (optimistic).** Playback starts immediately and the
-     *   count is only as durable as your write. **Do not debounce this, and do
-     *   not batch it with the answer autosave** — an eight-second debounce is
-     *   exactly long enough to start a third play and hard-reload. A `pagehide`
-     *   beacon is a backstop, not the mechanism. A crash between this call and
-     *   your write landing RETURNS the play to the learner; that is the honest
-     *   description of what you are buying.
-     * - **Return a promise (confirmed).** Playback is held — the button reads
-     *   "Preparing…" and is `aria-busy` — until it settles. Resolve with
-     *   `{ playsUsed }` from an ATOMIC server write (`UPDATE … SET plays = plays
-     *   + 1 … RETURNING plays`, or a compare-and-set on
-     *   `claim.previousPlaysUsed`). A resolved count above `maxPlays` refuses the
-     *   play, which is how a second tab is caught: two mounts both seeded at 0
-     *   both claim 1, and only an atomic increment can tell them apart. A
-     *   rejection charges nothing and lets the learner retry. This is the only
-     *   tier in which "consumed before audible" is true of storage rather than
-     *   only of memory; use it for summative papers.
-     *
-     * Never settle the promise and the learner cannot play at all: settle it.
+     * The evidence behind a stored grade, for `review`. Without it a graded
+     * outcome still shows its marks, rebuilt from `outcome.grade.details`; with
+     * neither, the score is shown and no marks are.
      */
-    onPlayConsumed?: (claim: MediaPlayClaim) => undefined | Promise<MediaPlayGrant | undefined>;
+    assessment?: SpeechAssessment;
     /**
-     * Called when a charged play produced no audio — the element errored before
-     * playback advanced past 0.25 s, an expired signed URL being the realistic
-     * cause. Supply it to give the play back, decrementing with a compare-and-set
-     * on `claim.playsUsed`. Omit it and the play stays spent: the SDK will not
-     * decrement a ledger it has no channel to correct.
+     * Confidence above which a break note is shown, 0..1, forwarded to
+     * {@link PronunciationFeedback}. No default — see its own prop.
      */
-    onPlayRefunded?: (claim: MediaPlayClaim) => void;
+    breakThreshold?: number;
+    /** The same, for the monotone note. */
+    monotoneThreshold?: number;
     /**
-     * Position reports, so a refresh resumes the play the learner already paid
-     * for instead of charging them again. Fires on pause, on end (with 0), and at
-     * most once per whole second of playback.
-     *
-     * **This one you MAY throttle** — the granularity you persist is the
-     * granularity of the replay a crash grants. Three seconds is sane; three
-     * minutes is not.
+     * The URL of a self-hosted copy of `CAPTURE_PROCESSOR_SOURCE`, handed to the
+     * recorder, for a Content-Security-Policy whose `script-src` does not allow
+     * `blob:`. Without it the capture module is loaded from a `blob:` URL, and a
+     * policy that refuses one sends every take through the deprecated
+     * main-thread `ScriptProcessorNode` — a take that still records, so nothing
+     * says so. See `useSpeechRecorder`'s option of the same name.
      */
-    onPosition?: (key: string, seconds: number) => void;
-    /** Translations for the transport chrome. Defaults are English. */
-    strings?: Partial<MediaTransportStrings>;
+    workletUrl?: string;
+    /**
+     * Never called. A read-aloud answer is a key in your storage, and there is
+     * none until the take has been uploaded — so there is no intermediate
+     * response to report, and reporting the take itself would offer a host a
+     * recording it has nowhere to put. `onSubmit` carries the response, once.
+     */
+    onChange?: (response: LearnerResponse) => void;
 }
+
 /**
- * Which slot a recording belongs to, stamped on every call the pager makes.
+ * How an activity is being presented. This is the single switch that decides
+ * whether the component may grade, reveal, or submit — the three things a
+ * summative exam must take away from the client.
  *
- * Exactly the shape {@link ActivitySequenceProps.onSubmit} already passes, so
- * one identity travels with the answer and with the take that answer points at
- * — and a consumer writes `slotId` in both places rather than reconciling two
- * spellings of "which question was this".
+ * - `practice` (default, and the only behaviour before `renderMode` existed):
+ *   the component owns the attempt. It
+ *   scores locally on submit, reveals correctness and feedback, and calls
+ *   `onComplete` with a full {@link ActivityResult}.
+ * - `exam`: the component NEVER scores and NEVER reveals correctness. Submit
+ *   emits the raw learner response through `onSubmit`; the server grades it.
+ *   Safe to render redacted data, because nothing here needs the answer key.
+ * - `review`: read-only. Renders the learner's submitted answer, and marks
+ *   correctness only from an `outcome` the caller supplies (which the server
+ *   computed). Nothing is submittable.
  */
-interface SequenceRecordingSlot {
-    /** Identity from `flattenSequence` — stable under shuffling. Store against THIS. */
-    slotId: string;
-    /** Presented position, which moves under shuffling. */
-    index: number;
-    activityId: string;
-}
+type RenderMode = 'practice' | 'exam' | 'review';
 /**
- * The pager-level half of a read-aloud recording binding: where every take in
- * this sequence is stored, and how a judgement comes back.
- *
- * One prop at both levels, because it is one concept — the media-budget
- * precedent ({@link SequenceMediaBudget} beside {@link MediaBudgetBinding}).
- * The difference is the second argument: a per-slot binding knows which slot it
- * belongs to, so a sequence-level one is told.
- *
- * The SDK records and hands over; it never judges. `assess` is `practice` only
- * and optional — a sequence that only stores takes gets the "assessment is not
- * available" notice rather than a throw — and `playbackUrl` is `review` only.
- * A slot whose activity is not a read-aloud never calls any of them.
+ * Makes the answer-key-bearing parts of an activity optional, so a component
+ * can render either full activity data OR a `redact()` projection with the
+ * same props. Fields the SDK classifies `answer-key` become optional here;
+ * a component in `exam` mode must not read them at all.
  */
-interface SequenceRecordingBinding {
-    /**
-     * Puts the take in your storage and returns its key. **Required** outside
-     * `review`: without it a learner can speak into a control that submits
-     * nothing, which the component refuses to render. Settle it.
-     */
-    upload(take: RecordedTake, slot: SequenceRecordingSlot): Promise<RecordingRef>;
-    /** Judges the stored take. `practice` only; an exam never assesses on the client. */
-    assess?(ref: RecordingRef, slot: SequenceRecordingSlot): Promise<ReadAloudAssessResult>;
-    /** A playable link to a stored take. `review` only. */
-    playbackUrl?(ref: RecordingRef, slot: SequenceRecordingSlot): Promise<string>;
-}
-
+type Renderable<TData> = Omit<TData, 'scoringStrategy'> & {
+    scoringStrategy?: unknown;
+    /** Present on a `redact()` projection. */
+    redacted?: true;
+};
 /**
- * Every string the SDK's own chrome renders.
- *
- * Until 0.8.1 these were literals, and `locale` set only the `lang` attribute —
- * so a learner sitting a Spanish paper read a Spanish passage inside an English
- * scaffold, and "No plays remaining" on a listening exam was untranslatable.
- * This is the whole surface, in one place, so a consumer can replace it.
+ * {@link Renderable} DISTRIBUTED over a union of activity types.
  *
- * **Interpolation and plurals are functions, not format strings.** A message
- * like `"Question {n} of {total}"` needs a parser, and a parser needs plural
- * rules for every locale the SDK does not know. A function hands both problems
- * to the consumer, who has `Intl.PluralRules` and knows their own language:
+ * This distinction is load-bearing, not cosmetic. `Renderable<T>` is built on
+ * `Omit`, and `Omit` does not distribute: `Omit<A | B, K>` collapses to the
+ * keys A and B have IN COMMON, so `Renderable<ActivityData>` is a single
+ * object type carrying only the fields every activity shares. Narrowing it
+ * dies with it — after `if (data.type === 'multiple-choice')` the compiler
+ * still refuses `data.options`, because the union it would narrow to no
+ * longer exists.
  *
- * ```ts
- * questionProgress: (index, total) => `Pregunta ${index} de ${total}`,
- * wordCount: (n) => `${n} ${n === 1 ? 'palabra' : 'palabras'}`,
- * ```
+ * The conditional below re-distributes, so `RenderableActivity` is a real
+ * union of per-type renderables and `.type` narrows again. Anything that
+ * accepts "some renderable activity, I don't know which" — a custom renderer,
+ * a sequence entry — must use THIS, not `Renderable<ActivityData>`.
+ */
+type RenderableActivity<TData extends ActivityData = ActivityData> = TData extends unknown ? Renderable<TData> : never;
+/**
+ * Sanitiser for author-supplied rich text (`questionHtml`, `promptHtml`, and a
+ * stimulus's `bodyHtml`). The SDK deliberately ships NO sanitiser — that would
+ * add a dependency and, worse, a false promise. Rich text is rendered only when
+ * you supply this function; without it the component falls back to the
+ * plain-text field, which is always escaped. Fail-safe by construction: the SDK
+ * never injects HTML it was not explicitly given a sanitiser for.
  *
- * It also lets a translation reorder its arguments, which a positional token
- * cannot, and TypeScript checks the arity. No parser, no message catalogue
- * format, no runtime dependency.
+ * `FillInTheBlanks.passageHtml` is the one exception, and is **never**
+ * rendered: the passage hosts the answer inputs, so it cannot be split at the
+ * `{{blank}}` placeholders without voiding the sanitiser. The plain `passage`
+ * is always used, and passing `passageHtml` warns in development.
+ */
+type HtmlSanitizer = (html: string) => string;
+/**
+ * The prop contract shared by every activity component (Req 3.1). Defined
+ * here (React-specific) rather than in lk-core, which is React-free.
  *
- * **What is deliberately NOT here: thrown errors.** Every `throw` in this
- * package is addressed to the developer who wired the component up, not to the
- * learner. Translating them would make them unsearchable and would put the one
- * audience who can act on them behind a translation. They stay English.
+ * Controlled / uncontrolled follows the React convention: pass `value` +
+ * `onChange` to own the learner's answer (restore an in-progress attempt,
+ * autosave a delta, drive a review); pass `defaultValue` to seed an
+ * uncontrolled component; pass neither to keep the pre-2.1.0 behaviour, where
+ * the component owns the answer outright.
  */
-interface LkStrings {
-    /** Multiple Choice submit button, and Written Response. */
-    submit: string;
-    /** Fill-in-the-Blanks in `practice`: the learner is checking their own work. */
-    checkAnswers: string;
-    /** Fill-in-the-Blanks in `exam`: nothing is checked on the client. */
-    submitAnswers: string;
-    /**
-     * The scored result, read by a screen reader on submit.
-     *
-     * `percent` is already rounded to a whole number. The authored overall
-     * feedback is appended SEPARATELY by the component, so a translation of this
-     * sentence never has to carry the author's words — the two were previously
-     * concatenated into one literal, which made the score sentence untranslatable
-     * without also touching authored content.
-     */
-    scoreAnnouncement: (percent: number, passed: boolean) => string;
-    /** Prefix announced on submit, before the score sentence. */
-    answerSubmitted: string;
-    /** An answer submitted for grading that has none yet. Never rendered as 0%. */
-    notGradedYet: string;
-    /** An outcome that carries no grade and never will. */
-    noGradeAvailable: string;
-    showFeedback: string;
-    hideFeedback: string;
-    /** Accessible name of a blank's input. `ordinal` is 1-based. */
-    blankLabel: (ordinal: number) => string;
-    /** Accessible name of the selector for one gap in a Gap Select passage. */
-    gapLabel: (ordinal: number) => string;
-    /**
-     * The empty first entry of a gap's selector — how a learner leaves a gap
-     * alone, and how they take an answer back. Never a real choice.
-     */
-    gapPlaceholder: string;
-    showHint: string;
-    hideHint: string;
-    /**
-     * Announced when an essay is handed in. Distinct from {@link LkStrings.awaitingGrade},
-     * which is the `review`-mode state of a submission made earlier: this one
-     * confirms the act, and is the only thing a learner hears at the moment they
-     * commit work that nothing on the client will grade.
-     */
-    responseSubmitted: string;
-    /** Live word counter. Needs the count for languages whose plural rules differ. */
-    wordCount: (count: number) => string;
-    /** The authored bounds, e.g. "50–200 words". `min` is 0 when unbounded below. */
-    wordBounds: (min: number, max: number) => string;
-    /** A rubric criterion the grader marked not applicable. */
-    notApplicable: string;
-    /** A returned grade flagged for a human to look at — learner-visible by design. */
-    awaitingHumanReview: string;
-    /** Submitted, no grade back yet. */
-    awaitingGrade: string;
-    /** The grader could not produce a grade. */
-    couldNotBeGraded: string;
-    previous: string;
-    next: string;
-    /** Progress label, also the question region's accessible name. `index` is 1-based. */
-    questionProgress: (index: number, total: number) => string;
-    /** Shown when no renderer is registered for an activity type. */
-    unsupportedActivity: string;
-    /** Accessible name of the box the learner types the recording into. */
-    dictationInputLabel: string;
-    /** Accessible name of the group holding the recording. */
-    dictationRecording: string;
-    /** Accessible name of the group holding the slower recording, and its default `alt`. */
-    dictationSlowRecording: string;
-    /** The progressive-hint button, with how many transcript words are shown so far. */
-    dictationRevealNextWord: (revealed: number, total: number) => string;
-    /** Hides every revealed hint word again. */
-    dictationResetHints: string;
-    /** The solution toggle: shows the transcript after the attempt is marked. */
-    showSolution: string;
-    hideSolution: string;
-    /** Accessible name of the revealed transcript. */
-    dictationSolutionLabel: string;
-    /** Accessible name of the word-by-word marked result. */
-    dictationMarksLabel: string;
-    /** Tells the learner the marks compare the normalised text, not what they typed. */
-    dictationDiffNote: string;
+interface ActivityProps<TData extends ActivityData = ActivityData> {
+    /** Activity content. Accepts a `redact()` projection in `exam` mode. */
+    data: RenderableActivity<TData>;
     /**
-     * The four sentences a screen reader hears for a marked word — the only
-     * channel the marks have for assistive technology; the glyphs and the
-     * character diff are decoration.
+     * Called when the component scored the attempt itself. Only ever fires in
+     * `practice` mode — in `exam` mode the client does not grade, so there is
+     * no `ActivityResult` to give you; use `onSubmit`.
      */
-    dictationWordCorrect: (word: string) => string;
-    dictationWordWrong: (word: string, expected: string) => string;
-    dictationWordMissing: (expected: string) => string;
-    dictationWordExtra: (word: string) => string;
-    /** The legend rows; the character-level marks reuse the same four. */
-    dictationLegendCorrect: string;
-    dictationLegendWrong: string;
-    dictationLegendMissing: string;
-    dictationLegendExtra: string;
-    /** Marked result of an attempt with no words in it once punctuation and spacing are ignored, an empty one included. */
-    dictationNothingTyped: string;
+    onComplete?: (result: ActivityResult) => void;
     /**
-     * Appended to the score announcement, e.g. "4 of 6 words correct." — a whole
-     * sentence, because authored feedback may follow it.
+     * Called on submit with the raw learner response and no grade. Fires in
+     * every mode, before `onComplete`, so an exam runner can persist the
+     * response and let the server score it.
      */
-    dictationWordsSummary: (correct: number, total: number) => string;
-    /** Accessible name of the group holding the model recording. */
-    readAloudModelRecording: string;
-    /** Accessible name of the group holding the slower model recording, and its default `alt`. */
-    readAloudSlowRecording: string;
-    /** Starts a take. */
-    readAloudRecord: string;
-    /** Ends the take in progress. */
-    readAloudStop: string;
-    /** Throws the take away so the learner can start over. */
-    readAloudRerecord: string;
-    /** Accessible name of the player for the take the learner just made. */
-    readAloudYourRecording: string;
+    onSubmit?: (response: LearnerResponse) => void;
+    /** Controlled value: the learner's current response. */
+    value?: LearnerResponse;
+    /** Initial response for an uncontrolled component (ignored when `value` is set). */
+    defaultValue?: LearnerResponse;
     /**
-     * In place of the player for the learner's own take, and of the buttons that
-     * play one word of it, when the page refuses to play it — most often a
-     * Content-Security-Policy whose `media-src` does not allow `blob:`. Said
-     * rather than left as controls that do nothing when pressed.
+     * Mount the component as already submitted — read at mount only, like any
+     * `default*` prop.
+     *
+     * Restoring an attempt without it reopens a question the learner had already
+     * submitted as answerable, so on a summative paper they can change and
+     * re-submit it. `AttemptState.submittedSlotIds` is what this consumes.
      */
-    readAloudPlaybackUnavailable: string;
+    defaultSubmitted?: boolean;
+    /** Fires on every change to the learner's response. Required for a controlled component. */
+    onChange?: (response: LearnerResponse) => void;
+    /** Presentation mode. Defaults to `practice`. */
+    renderMode?: RenderMode;
     /**
-     * Live progress while recording. Whole seconds, not a `m:ss` clock: a
-     * recording is bounded in seconds by the item, and a translation should not
-     * have to reimplement a clock to change the word around it.
-     *
-     * Shown on screen and hidden from assistive technology: it changes every
-     * second, and a screen reader that spoke each change would speak into the
-     * take being assessed. The two sentences below are what is announced instead.
+     * Server-computed outcome, used by `review` mode to mark correctness
+     * without the client ever scoring. Ignored in other modes.
      */
-    readAloudRecordingProgress: (seconds: number, maxSeconds: number) => string;
-    /** Announced once when a capture begins. */
-    readAloudRecordingStarted: string;
+    outcome?: ItemOutcome;
+    /** Renders author-supplied rich text when provided. See {@link HtmlSanitizer}. */
+    sanitizeHtml?: HtmlSanitizer;
     /**
-     * Announced once when a capture ends, by the learner or at its own bound.
-     * Carries the length because the progress counter is not announced: a take
-     * that reads back as "20 of 20 seconds" is one that stopped itself.
+     * Binds this activity's own `data.media` to a play budget the consumer
+     * persists. Usually supplied by `<ActivitySequence mediaBudget={…}>`; pass it
+     * yourself when rendering an activity standalone.
      */
-    readAloudRecordingStopped: (seconds: number, maxSeconds: number) => string;
-    /** How many takes are left. Called with 0 as well, so the wording is one translation's. */
-    readAloudTakesRemaining: (remaining: number, max: number) => string;
-    /** `exam` only: hands the item in with no recording at all, deliberately. */
-    readAloudSubmitWithoutRecording: string;
-    /** Pending, while the take travels to the application's storage. */
-    readAloudUploading: string;
-    /** The take never reached storage, so nothing was submitted. */
-    readAloudUploadFailed: string;
-    /** Retries whichever step just failed. */
-    readAloudTryAgain: string;
-    /** Pending, while the assessor judges the take. */
-    readAloudAssessing: string;
-    /** The binding stores recordings but judges none, so there is no feedback to show. */
-    readAloudAssessmentUnavailable: string;
-    /** The assessor found no speech, or too little of it, in the take. */
-    readAloudNotHeard: string;
-    /** The assessor produced no grade for any other reason. The code itself is never shown. */
-    readAloudNotAssessed: string;
-    /** The assessment could not be run at all — a failure of the call, not of the reading. */
-    readAloudAssessmentFailed: string;
+    mediaBudget?: MediaBudgetBinding;
+    /** Translations for the audio transport chrome. See {@link MediaTransportStrings}. */
+    mediaStrings?: Partial<MediaTransportStrings>;
     /**
-     * What went wrong with the microphone or with the take. One function rather
-     * than five keys, so a translation keeps the five sentences together and the
-     * SDK keeps one name for the concept.
+     * Overrides the SDK's chrome text for this activity, layered on whatever
+     * `LkIntlProvider` supplies. `mediaStrings` still works and is merged after
+     * this, so an existing 0.8.x call site keeps behaving as it did.
      */
-    readAloudRecorderError: (reason: SpeechRecorderError) => string;
-    /** Accessible name of the whole feedback region. */
-    pronunciationFeedbackLabel: string;
-    /** Name of one scored dimension, as a learner reads it. */
-    pronunciationDimension: (dimension: ReadAloudDimension) => string;
-    /** A dimension or a word the engine did not measure. NEVER rendered as 0%. */
-    pronunciationNotAssessed: string;
-    /** Accessible name of the word-by-word marks. */
-    pronunciationWordsLabel: string;
-    /** One legend row per marking state — the same four states the marks carry. */
-    pronunciationLegend: (state: ReadAloudWordState) => string;
+    strings?: LkStringsOverride;
+    onInteraction?: (event: InteractionEvent) => void;
     /**
-     * The four sentences a screen reader hears for a marked word: the only
-     * channel the marks have for assistive technology, since the glyph and the
-     * decoration are both hidden from it.
+     * The host's AI ports for this activity — an explanation after grading, hints
+     * before submit — overriding `LkAiProvider`'s. Leave a port out to switch
+     * that help off. Nothing AI appears in `exam`, and an item whose author
+     * switched a feature off (`data.ai`) never shows it. See {@link LearnerAi}.
      */
-    pronunciationWordCorrect: (word: string) => string;
-    pronunciationWordMispronounced: (word: string) => string;
-    pronunciationWordOmitted: (word: string) => string;
-    pronunciationWordInserted: (word: string) => string;
-    /** Opens one word's syllables, sounds and timings. */
-    pronunciationWordDetails: (word: string) => string;
-    pronunciationSyllables: string;
-    pronunciationPhonemes: string;
-    /** A syllable the engine also spelled out, e.g. `('ˈhæ', 'ha')`. */
-    pronunciationSyllableSpelling: (syllable: string, grapheme: string) => string;
-    /** A sound the engine named no symbol for; `ordinal` is 1-based. */
-    pronunciationPhonemePosition: (ordinal: number) => string;
-    /** Introduces the sounds the engine thought it heard in a sound's place. */
-    pronunciationHeardAs: string;
-    /** Plays one word out of the learner's own take. */
-    pronunciationPlayWord: (word: string) => string;
-    pronunciationBreakUnexpected: string;
-    pronunciationBreakMissing: string;
-    /** Shown only past the caller's own monotone threshold; the SDK sets none. */
-    pronunciationMonotone: string;
-    /** Names the alphabet the phoneme symbols are written in. */
-    pronunciationIpaNote: string;
-    /** Jump buttons, e.g. "Back 10 seconds". */
-    videoBack: (seconds: number) => string;
-    videoForward: (seconds: number) => string;
-    /** The centre button once the video has ended. */
-    videoReplay: string;
-    /** The time readout flips between elapsed and remaining; these name what a press shows next. */
-    videoShowRemaining: string;
-    videoShowElapsed: string;
-    /** The captions button, named by what a press does. */
-    videoCaptionsShow: string;
-    videoCaptionsHide: string;
-    /** In the captions menu when a caption file could not be read. */
-    videoCaptionsFailed: string;
-    /** The same, for the second language: the first line keeps working. */
-    videoSecondaryCaptionsFailed: string;
-    /** A speed in the speed menu, e.g. "1.25×". */
-    videoSpeedValue: (rate: number) => string;
-    videoSettings: string;
-    videoCaptionLanguage: string;
-    /** The captions page's item, and page, for a second caption line under the first. */
-    videoSecondCaptionLanguage: string;
+    ai?: LearnerAi;
+    /** Per-instance token overrides, applied as inline CSS vars on the root. */
+    theme?: Partial<ThemeTokens>;
     /**
-     * The captions row of the settings menu when two languages show, from the
-     * tracks' own labels: "English + Español". A translation may order them as its
-     * language reads, but the first argument is always the upper line.
+     * BCP 47 tag stamped as `lang` on this component's root. This is the
+     * INTERFACE language — the SDK's own chrome renders inside that element — so
+     * it should carry the same value you give `<LkIntlProvider locale>`. Passing
+     * a different one re-declares the language of every SDK string in this
+     * subtree without changing the words.
+     *
+     * It is NOT `data.locale`, which labels xAPI statements — and, on a
+     * dictation, places the dictation's own words: `<Dictation>` puts it, and
+     * the direction it names, on its title, hints, marks and solution. Other
+     * authored content in another language belongs on `stimulus.locale`, which
+     * `<StimulusPanel>` puts on the passage alone.
      */
-    videoCaptionPair: (primary: string, secondary: string) => string;
-    /** Announced when Shift + C finds no other language to show. */
-    videoNoSecondLanguage: string;
-    videoCaptionSize: string;
-    videoCaptionSizeValue: (size: CaptionSize) => string;
-    videoCaptionBackground: string;
-    videoKeyboardShortcuts: string;
-    videoShortcutList: string;
-    /** Closes the shortcut list. */
-    videoClose: string;
-    /** A setting's state in the settings menu. */
-    videoOn: string;
-    videoOff: string;
-    /** What each row of the shortcut list does. */
-    videoShortcut: (action: VideoShortcutAction) => string;
-    /** The button that opens the panel below the video, and its two tabs. */
-    videoPanel: string;
-    videoContents: string;
-    videoTranscript: string;
-    videoTranscriptSearch: string;
-    videoTranscriptNoMatch: string;
-    videoPictureInPicture: string;
-    videoFullscreen: string;
-    videoExitFullscreen: string;
+    locale?: string;
+    disabled?: boolean;
+}
+/**
+ * Bridges a server-produced `redact()` projection into the `data` prop.
+ *
+ * `RedactedActivityData` is deliberately index-signature typed in lk-core — it
+ * proves a payload is learner-safe, not what shape it has — so TypeScript
+ * cannot know it still carries the public fields a renderer needs. This is the
+ * SDK's single, documented crossing of that gap, so an exam runner does not
+ * have to write `as unknown as` at every call site:
+ *
+ * ```tsx
+ * <MultipleChoice
+ *   data={asRenderable<MultipleChoiceData>(redactedFromServer)}
+ *   renderMode="exam"
+ *   onSubmit={persist}
+ * />
+ * ```
+ *
+ * Safe because `exam` mode reads only public fields; the answer-key fields the
+ * type claims are exactly the ones the component is forbidden to touch there.
+ *
+ * Per-type redacted interfaces (`RedactedMultipleChoiceData`, …) ship from
+ * lk-core since 0.6.0, but they are not yet *assignable* to `data`:
+ * {@link Renderable} widens `scoringStrategy` and leaves nested answer-key
+ * fields (`options[].isCorrect`, `blanks[].acceptedAnswers`) required, so a
+ * real redacted payload still needs this bridge. Closing that gap is tracked
+ * in the roadmap.
+ */
+declare function asRenderable<TData extends ActivityData>(redacted: RedactedActivityData): Renderable<TData>;
+/**
+ * The same bridge as {@link asRenderable}, for a whole sequence: activities
+ * and item groups as a server hands them over, ready for `<ActivitySequence>`.
+ *
+ * Needed for the same reason and no other. `redactItemGroup` returns
+ * `ItemGroup<RedactedActivityData>`, and `RedactedActivityData` is an
+ * index-signature type whose fields are all `unknown` — so its `question` is
+ * not a `string` and it satisfies no per-type renderable, however the prop is
+ * widened. Widening alone cannot fix this; a crossing point is required, and
+ * having exactly one keeps `as unknown as` out of consumer code.
+ *
+ * ```tsx
+ * const entries = await fetchExam();            // redacted, server-side
+ * <ActivitySequence
+ *   activities={asRenderableSequence(entries)}
+ *   renderMode="exam"                           // REQUIRED: see below
+ *   shuffleSeed={attemptId}
+ *   onSubmit={persist}
+ * />
+ * ```
+ *
+ * Pass `renderMode="exam"` (or `"review"`). Redacted data has no answer key, and
+ * almost every built-in activity throws at render in the default `practice`
+ * mode rather than fail later: `<MultipleChoice>`, `<FillInTheBlanks>`,
+ * `<GapSelect>` and `<Dictation>` because they grade locally, and
+ * `<WrittenResponse>` because `practice` still runs its local submit path and
+ * emits a practice-mode xAPI statement.
+ *
+ * `<ReadAloud>` is the exception and renders a projection in every mode: a
+ * read-aloud item has no answer key to withhold, so `redact()` removes only the
+ * authored feedback and leaves the reading, its language and its bounds — which
+ * is everything the component puts on screen. It grades nothing locally either;
+ * the grade comes back from whatever the application asked to judge the take.
+ */
+declare function asRenderableSequence(entries: readonly (RedactedActivityData | RedactedItemGroupData)[]): readonly SequenceEntry<RenderableActivity>[];
+/** Structural shape of a `redactItemGroup()` projection, as it arrives from a server. */
+type RedactedItemGroupData = ItemGroup<RedactedActivityData> & {
+    redacted: true;
+};
+/**
+ * Every word the SDK's audio transport renders.
+ *
+ * Words, not characters: the `m:ss / m:ss` clock is digits and punctuation and
+ * is formatted by the component, because it reads identically in every locale
+ * this SDK targets. The scrubber's SPOKEN value does have a word in it and does
+ * have a key ({@link MediaTransportStrings.timeValue}).
+ *
+ * Supply them to translate it. These are the highest-stakes strings on a
+ * listening paper — "No plays remaining" decides whether a learner believes
+ * they may try again — so shipping them as untranslatable English inside a
+ * Spanish panel was not acceptable. Supplying any of them also sets `lang` on
+ * the transport chrome, so a screen reader does not read the SDK's own words
+ * with the passage's phonetics.
+ */
+interface MediaTransportStrings {
+    play: string;
+    pause: string;
+    preparing: string;
+    mute: string;
+    unmute: string;
+    volume: string;
+    speed: string;
+    seek: string;
     /**
-     * Why the video will not play, by `MediaError.code` (1 aborted, 2 network,
-     * 3 decode, 4 source), with 0 for anything else.
+     * Spoken value of the scrubber, e.g. `('1:05', '4:30') => '1:05 of 4:30'`.
+     * Takes ALREADY-FORMATTED `m:ss` strings: a translation should not have to
+     * reimplement the clock to change the word between them.
      */
-    videoError: (code: number) => string;
-    videoTryAgain: string;
-    /** A quiz with no title of its own. */
-    videoQuiz: string;
-    /** Where the learner is inside a quiz, e.g. "Question 2 of 5". */
-    videoQuestionProgress: (index: number, total: number) => string;
-    /** A step of the quiz's step indicator, for assistive technology. */
-    videoQuestionStep: (index: number, answered: boolean) => string;
-    videoNextQuestion: string;
-    videoContinue: string;
-    videoSkipQuiz: string;
-    videoRewatch: string;
-    /** Exam mode, once a question is submitted: saved, not graded. */
-    videoAnswerSaved: string;
-    /** The end card, while an answer is still being stored or graded: why Finish waits. */
-    videoAnswerPending: string;
-    videoRequired: string;
-    /** A quiz's progress in the contents panel and on the end screen. */
-    videoQuizProgress: (answered: number, total: number) => string;
-    /** Announced when a quiz opens. */
-    videoQuizOpened: (time: string, questions: number) => string;
-    /** Announced when a seek stopped at a required quiz. */
-    videoHeldAtQuiz: (time: string) => string;
-    /** Announced when a seek stopped at the furthest point reached. */
-    videoHeldAhead: string;
-    videoEnded: string;
-    /** Practice end screen: questions answered, and the score. */
-    videoEndScore: (answered: number, total: number, percent: number) => string;
-    /** Exam end screen: questions answered, no score. */
-    videoEndAnswered: (answered: number, total: number) => string;
-    videoWatchAgain: string;
-    videoFinish: string;
+    timeValue: (elapsed: string, duration: string) => string;
+    /** e.g. `(1, 2) => '1 of 2 plays remaining'`. */
+    playsRemaining: (remaining: number, max: number) => string;
+    noPlaysRemaining: string;
+    /** Shown before the LAST play is spent, so a stray press cannot cost it. */
+    lastPlayConfirm: string;
+    lastPlayStart: string;
+    lastPlayCancel: string;
+    seekBlocked: string;
+    rateBlocked: string;
+    playFailed: string;
+}
+/**
+ * Binds ONE media block to a play budget the consumer persists.
+ *
+ * The SDK refuses a play; it does not remember one. Everything durable here is
+ * the consuming application's — see {@link SequenceMediaBudget.onPlayConsumed}.
+ */
+interface MediaBudgetBinding {
+    /** From `slotMediaKey(slotId)` / `stimulusMediaKey(slotId)` in lk-core. */
+    key: string;
+    /** Plays already spent, and where playback stood. Read at mount only. */
+    entry?: MediaPlayLedgerEntry;
+    /** Defaults to `renderMode !== 'review'`. An explicit boolean wins either way. */
+    enforced?: boolean;
+    /** Slot context stamped onto the claim and the interaction event. */
+    slotId: string;
+    index: number;
+    activityId?: string;
+    onPlayConsumed?: (claim: MediaPlayClaim) => undefined | Promise<MediaPlayGrant | undefined>;
+    onPlayRefunded?: (claim: MediaPlayClaim) => void;
+    onPosition?: (key: string, seconds: number) => void;
+    /** Translations for the transport chrome. */
+    strings?: Partial<MediaTransportStrings>;
+}
+/**
+ * The pager-level half of a play budget. One prop, because it is one concept.
+ */
+interface SequenceMediaBudget {
     /**
-     * `<ActivityPreview>`, in place of a draft that still has something missing.
-     * Author-facing, not learner-facing — but an editor is translated too.
+     * `MediaPlayLedger.entries` goes straight in. An absent key means nothing
+     * spent. Read at mount, like `responses`.
      */
-    previewIncomplete: string;
-    /** `<ActivityPreview>`, in place of a draft with something wrong in it. */
-    previewInvalid: string;
+    plays?: Readonly<Record<string, MediaPlayLedgerEntry>>;
     /**
-     * Accessible name of a provider iframe whose author supplied no `alt`.
-     * `MediaSchema` requires `alt` on an embed, so validated content never
-     * reaches this — but `validateActivity` is opt-in, and a screen-reader
-     * learner meeting an unvalidated one should not meet it in English.
+     * Re-seed token. Change this string and the budgets re-seed from `plays`
+     * WITHOUT remounting the pager — the invigilator path ("the audio never
+     * started, give her the play back") that would otherwise cost the learner
+     * their focus, their scroll position and an unsaved answer.
      */
-    embeddedMedia: string;
+    resumeKey?: string;
+    /** Explicit override of the default (`renderMode !== 'review'`). */
+    enforced?: boolean;
     /**
-     * Accessible name of the stimulus region when the author gave it no title.
-     * Keyed by `Stimulus['kind']`, because "Recording" and "Passage" do not share
-     * a gender or an article in every language.
+     * Called the instant a play is claimed, BEFORE any audio is audible.
+     *
+     * Two tiers, chosen by what you return:
+     *
+     * - **Return nothing (optimistic).** Playback starts immediately and the
+     *   count is only as durable as your write. **Do not debounce this, and do
+     *   not batch it with the answer autosave** — an eight-second debounce is
+     *   exactly long enough to start a third play and hard-reload. A `pagehide`
+     *   beacon is a backstop, not the mechanism. A crash between this call and
+     *   your write landing RETURNS the play to the learner; that is the honest
+     *   description of what you are buying.
+     * - **Return a promise (confirmed).** Playback is held — the button reads
+     *   "Preparing…" and is `aria-busy` — until it settles. Resolve with
+     *   `{ playsUsed }` from an ATOMIC server write (`UPDATE … SET plays = plays
+     *   + 1 … RETURNING plays`, or a compare-and-set on
+     *   `claim.previousPlaysUsed`). A resolved count above `maxPlays` refuses the
+     *   play, which is how a second tab is caught: two mounts both seeded at 0
+     *   both claim 1, and only an atomic increment can tell them apart. A
+     *   rejection charges nothing and lets the learner retry. This is the only
+     *   tier in which "consumed before audible" is true of storage rather than
+     *   only of memory; use it for summative papers.
+     *
+     * Never settle the promise and the learner cannot play at all: settle it.
      */
-    stimulusKind: Record<Stimulus['kind'], string>;
+    onPlayConsumed?: (claim: MediaPlayClaim) => undefined | Promise<MediaPlayGrant | undefined>;
     /**
-     * How far the material carries, e.g. "Questions 3–8". Called with equal
-     * `first` and `last` for a single question, so a translation can choose its
-     * own singular rather than receive a pre-pluralised English one.
+     * Called when a charged play produced no audio — the element errored before
+     * playback advanced past 0.25 s, an expired signed URL being the realistic
+     * cause. Supply it to give the play back, decrementing with a compare-and-set
+     * on `claim.playsUsed`. Omit it and the play stays spent: the SDK will not
+     * decrement a ledger it has no channel to correct.
      */
-    stimulusRange: (first: number, last: number) => string;
-    /** Production fallback when an activity throws during render. */
-    activityFailed: string;
-    /** The same, when the activity's title is known. */
-    activityFailedNamed: (title: string) => string;
-    /** Production fallback when the activity has no title to name. */
-    activityFailedUnnamed: string;
-    /** The button that asks for an explanation of a graded answer. */
-    aiExplain: string;
-    /** The same button while the explanation is being written. */
-    aiExplaining: string;
-    /** The heading over an explanation, and its accessible name. */
-    aiExplanation: string;
-    /** When no explanation can be shown: the port failed, or its answer was refused. */
-    aiExplanationUnavailable: string;
-    /** The button that asks for a hint. */
-    aiHint: string;
-    /** The same button while the hint is being written. */
-    aiHintLoading: string;
-    /** The label before each hint. */
-    aiHintNumber: (hintNumber: number) => string;
-    /** The accessible name of the list of hints. */
-    aiHints: string;
-    /** When no hint can be shown: the port failed, or its hint gave the answer away. */
-    aiHintUnavailable: string;
-    /** In place of the hint button once every hint has been used. */
-    aiNoMoreHints: string;
-    /** Beneath every AI text: who wrote it. */
-    aiNotice: string;
+    onPlayRefunded?: (claim: MediaPlayClaim) => void;
     /**
-     * The listening-paper transport. Shipped in 0.8.0 as its own `mediaStrings`
-     * prop, which still works — this is the same shape, reachable from the one
-     * provider so a consumer does not wire two mechanisms.
+     * Position reports, so a refresh resumes the play the learner already paid
+     * for instead of charging them again. Fires on pause, on end (with 0), and at
+     * most once per whole second of playback.
+     *
+     * **This one you MAY throttle** — the granularity you persist is the
+     * granularity of the replay a crash grants. Three seconds is sane; three
+     * minutes is not.
      */
-    media: MediaTransportStrings;
+    onPosition?: (key: string, seconds: number) => void;
+    /** Translations for the transport chrome. Defaults are English. */
+    strings?: Partial<MediaTransportStrings>;
 }
-/** A partial override, nested one level for {@link LkStrings.media}. */
-type LkStringsOverride = Partial<Omit<LkStrings, 'media' | 'stimulusKind'>> & {
-    media?: Partial<MediaTransportStrings>;
-    stimulusKind?: Partial<Record<Stimulus['kind'], string>>;
-};
 /**
- * English defaults, byte-identical to what every component rendered before the
- * strings surface existed. Supplying no override changes nothing on screen.
+ * Which slot a recording belongs to, stamped on every call the pager makes.
+ *
+ * Exactly the shape {@link ActivitySequenceProps.onSubmit} already passes, so
+ * one identity travels with the answer and with the take that answer points at
+ * — and a consumer writes `slotId` in both places rather than reconciling two
+ * spellings of "which question was this".
  */
-declare const DEFAULT_STRINGS: LkStrings;
+interface SequenceRecordingSlot {
+    /** Identity from `flattenSequence` — stable under shuffling. Store against THIS. */
+    slotId: string;
+    /** Presented position, which moves under shuffling. */
+    index: number;
+    activityId: string;
+}
 /**
- * Layers an override onto a base dictionary.
+ * The pager-level half of a read-aloud recording binding: where every take in
+ * this sequence is stored, and how a judgement comes back.
  *
- * Two levels deep and no further, because the shape is two levels deep. A
- * generic deep merge would silently accept a nested object where a function
- * belongs and fail at render instead of at the call site.
+ * One prop at both levels, because it is one concept — the media-budget
+ * precedent ({@link SequenceMediaBudget} beside {@link MediaBudgetBinding}).
+ * The difference is the second argument: a per-slot binding knows which slot it
+ * belongs to, so a sequence-level one is told.
+ *
+ * The SDK records and hands over; it never judges. `assess` is `practice` only
+ * and optional — a sequence that only stores takes gets the "assessment is not
+ * available" notice rather than a throw — and `playbackUrl` is `review` only.
+ * A slot whose activity is not a read-aloud never calls any of them.
  */
-declare function mergeStrings(base: LkStrings, override?: LkStringsOverride): LkStrings;
+interface SequenceRecordingBinding {
+    /**
+     * Puts the take in your storage and returns its key. **Required** outside
+     * `review`: without it a learner can speak into a control that submits
+     * nothing, which the component refuses to render. Settle it.
+     */
+    upload(take: RecordedTake, slot: SequenceRecordingSlot): Promise<RecordingRef>;
+    /** Judges the stored take. `practice` only; an exam never assesses on the client. */
+    assess?(ref: RecordingRef, slot: SequenceRecordingSlot): Promise<ReadAloudAssessResult>;
+    /** A playable link to a stored take. `review` only. */
+    playbackUrl?(ref: RecordingRef, slot: SequenceRecordingSlot): Promise<string>;
+}
 
 export { type ActivityProps as A, type CaptionSize as C, DEFAULT_STRINGS as D, type HtmlSanitizer as H, type LkStrings as L, type MediaBudgetBinding as M, type ReadAloudAssessResult as R, type SequenceMediaBudget as S, type VideoPreferences as V, type LkStringsOverride as a, type MediaTransportStrings as b, type ReadAloudProps as c, type RecordingBinding as d, type RenderMode as e, type Renderable as f, type RenderableActivity as g, type SequenceRecordingBinding as h, type SequenceRecordingSlot as i, asRenderable as j, asRenderableSequence as k, mergeStrings as m };