@intellectif/lk-react 12.0.1 → 14.0.0

package/dist/{strings-CN7n-BlE.d.ts → strings--ADnHcaA.d.cts}

@@ -1,4 +1,74 @@
-import { ActivityData, ActivityResult, LearnerResponse, ItemOutcome, MediaPlayLedgerEntry, MediaPlayClaim, MediaPlayGrant, InteractionEvent, ThemeTokens, RedactedActivityData, ItemGroup, SequenceEntry, Stimulus } from '@intellectif/lk-core';
+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 { R as RecordedTake, S as SpeechRecorderError } from './machine-CuwKqWXC.cjs';
+
+/**
+ * What an application's assessor came back with.
+ *
+ * `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.
+ *
+ * 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 RecordingBinding {
+    /**
+     * 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.
+     */
+    upload(take: RecordedTake): Promise<RecordingRef>;
+    /**
+     * 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.
+     */
+    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;
+    /**
+     * 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.
+     */
+    assessment?: SpeechAssessment;
+    /**
+     * Confidence above which a break note is shown, 0..1, forwarded to
+     * {@link PronunciationFeedback}. No default — see its own prop.
+     */
+    breakThreshold?: number;
+    /** The same, for the monotone note. */
+    monotoneThreshold?: number;
+    /**
+     * 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;
+}
 
 /**
  * How an activity is being presented. This is the single switch that decides
@@ -132,8 +202,10 @@ interface ActivityProps<TData extends ActivityData = ActivityData> {
      * 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 only. Authored
-     * content in another language belongs on `stimulus.locale`, which
+     * 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.
      */
     locale?: string;
@@ -189,10 +261,17 @@ declare function asRenderable<TData extends ActivityData>(redacted: RedactedActi
  * ```
  *
  * Pass `renderMode="exam"` (or `"review"`). Redacted data has no answer key, and
- * all three built-in activities throw at render in the default `practice` mode
- * rather than fail later: `<MultipleChoice>` and `<FillInTheBlanks>` because
- * they grade locally, and `<WrittenResponse>` because `practice` still runs its
- * local submit path and emits a practice-mode xAPI statement.
+ * 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. */
@@ -328,6 +407,47 @@ interface SequenceMediaBudget {
     /** Translations for the transport chrome. Defaults are English. */
     strings?: Partial<MediaTransportStrings>;
 }
+/**
+ * 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".
+ */
+interface SequenceRecordingSlot {
+    /** Identity from `flattenSequence` — stable under shuffling. Store against THIS. */
+    slotId: string;
+    /** Presented position, which moves under shuffling. */
+    index: number;
+    activityId: string;
+}
+/**
+ * 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.
+ */
+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>;
+}
 
 /**
  * Every string the SDK's own chrome renders.
@@ -417,6 +537,139 @@ interface LkStrings {
     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;
+    /**
+     * 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.
+     */
+    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;
+    /**
+     * Appended to the score announcement, e.g. "4 of 6 words correct." — a whole
+     * sentence, because authored feedback may follow 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;
+    /**
+     * 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.
+     */
+    readAloudRecordingProgress: (seconds: number, maxSeconds: number) => string;
+    /** Announced once when a capture begins. */
+    readAloudRecordingStarted: string;
+    /**
+     * 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.
+     */
+    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;
+    /**
+     * 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.
+     */
+    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;
+    /**
+     * 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.
+     */
+    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;
     /**
      * `<ActivityPreview>`, in place of a draft that still has something missing.
      * Author-facing, not learner-facing — but an editor is translated too.
@@ -475,4 +728,4 @@ declare const DEFAULT_STRINGS: LkStrings;
  */
 declare function mergeStrings(base: LkStrings, override?: LkStringsOverride): LkStrings;
 
-export { type ActivityProps as A, DEFAULT_STRINGS as D, type HtmlSanitizer as H, type LkStrings as L, type MediaBudgetBinding as M, type RenderMode as R, type SequenceMediaBudget as S, type LkStringsOverride as a, type MediaTransportStrings as b, type Renderable as c, type RenderableActivity as d, asRenderable as e, asRenderableSequence as f, mergeStrings as m };
+export { type ActivityProps as A, 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 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 };

package/dist/{strings-CN7n-BlE.d.cts → strings-CtdSf2St.d.ts}

@@ -1,4 +1,74 @@
-import { ActivityData, ActivityResult, LearnerResponse, ItemOutcome, MediaPlayLedgerEntry, MediaPlayClaim, MediaPlayGrant, InteractionEvent, ThemeTokens, RedactedActivityData, ItemGroup, SequenceEntry, Stimulus } from '@intellectif/lk-core';
+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 { R as RecordedTake, S as SpeechRecorderError } from './machine-CuwKqWXC.js';
+
+/**
+ * What an application's assessor came back with.
+ *
+ * `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.
+ *
+ * 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 RecordingBinding {
+    /**
+     * 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.
+     */
+    upload(take: RecordedTake): Promise<RecordingRef>;
+    /**
+     * 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.
+     */
+    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;
+    /**
+     * 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.
+     */
+    assessment?: SpeechAssessment;
+    /**
+     * Confidence above which a break note is shown, 0..1, forwarded to
+     * {@link PronunciationFeedback}. No default — see its own prop.
+     */
+    breakThreshold?: number;
+    /** The same, for the monotone note. */
+    monotoneThreshold?: number;
+    /**
+     * 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;
+}
 
 /**
  * How an activity is being presented. This is the single switch that decides
@@ -132,8 +202,10 @@ interface ActivityProps<TData extends ActivityData = ActivityData> {
      * 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 only. Authored
-     * content in another language belongs on `stimulus.locale`, which
+     * 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.
      */
     locale?: string;
@@ -189,10 +261,17 @@ declare function asRenderable<TData extends ActivityData>(redacted: RedactedActi
  * ```
  *
  * Pass `renderMode="exam"` (or `"review"`). Redacted data has no answer key, and
- * all three built-in activities throw at render in the default `practice` mode
- * rather than fail later: `<MultipleChoice>` and `<FillInTheBlanks>` because
- * they grade locally, and `<WrittenResponse>` because `practice` still runs its
- * local submit path and emits a practice-mode xAPI statement.
+ * 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. */
@@ -328,6 +407,47 @@ interface SequenceMediaBudget {
     /** Translations for the transport chrome. Defaults are English. */
     strings?: Partial<MediaTransportStrings>;
 }
+/**
+ * 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".
+ */
+interface SequenceRecordingSlot {
+    /** Identity from `flattenSequence` — stable under shuffling. Store against THIS. */
+    slotId: string;
+    /** Presented position, which moves under shuffling. */
+    index: number;
+    activityId: string;
+}
+/**
+ * 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.
+ */
+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>;
+}
 
 /**
  * Every string the SDK's own chrome renders.
@@ -417,6 +537,139 @@ interface LkStrings {
     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;
+    /**
+     * 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.
+     */
+    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;
+    /**
+     * Appended to the score announcement, e.g. "4 of 6 words correct." — a whole
+     * sentence, because authored feedback may follow 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;
+    /**
+     * 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.
+     */
+    readAloudRecordingProgress: (seconds: number, maxSeconds: number) => string;
+    /** Announced once when a capture begins. */
+    readAloudRecordingStarted: string;
+    /**
+     * 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.
+     */
+    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;
+    /**
+     * 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.
+     */
+    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;
+    /**
+     * 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.
+     */
+    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;
     /**
      * `<ActivityPreview>`, in place of a draft that still has something missing.
      * Author-facing, not learner-facing — but an editor is translated too.
@@ -475,4 +728,4 @@ declare const DEFAULT_STRINGS: LkStrings;
  */
 declare function mergeStrings(base: LkStrings, override?: LkStringsOverride): LkStrings;
 
-export { type ActivityProps as A, DEFAULT_STRINGS as D, type HtmlSanitizer as H, type LkStrings as L, type MediaBudgetBinding as M, type RenderMode as R, type SequenceMediaBudget as S, type LkStringsOverride as a, type MediaTransportStrings as b, type Renderable as c, type RenderableActivity as d, asRenderable as e, asRenderableSequence as f, mergeStrings as m };
+export { type ActivityProps as A, 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 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 };

package/dist/theme/ThemeProvider.cjs

@@ -1,29 +1,29 @@
 'use client';
 'use strict';
 
-var chunkAMGK7DDM_cjs = require('../chunk-AMGK7DDM.cjs');
+var chunkD4DQFTA7_cjs = require('../chunk-D4DQFTA7.cjs');
 
 
 
 Object.defineProperty(exports, "ThemeProvider", {
   enumerable: true,
-  get: function () { return chunkAMGK7DDM_cjs.ThemeProvider; }
+  get: function () { return chunkD4DQFTA7_cjs.ThemeProvider; }
 });
 Object.defineProperty(exports, "createTailwindTheme", {
   enumerable: true,
-  get: function () { return chunkAMGK7DDM_cjs.createTailwindTheme; }
+  get: function () { return chunkD4DQFTA7_cjs.createTailwindTheme; }
 });
 Object.defineProperty(exports, "darkTheme", {
   enumerable: true,
-  get: function () { return chunkAMGK7DDM_cjs.darkTheme; }
+  get: function () { return chunkD4DQFTA7_cjs.darkTheme; }
 });
 Object.defineProperty(exports, "defaultTheme", {
   enumerable: true,
-  get: function () { return chunkAMGK7DDM_cjs.defaultTheme; }
+  get: function () { return chunkD4DQFTA7_cjs.defaultTheme; }
 });
 Object.defineProperty(exports, "useTheme", {
   enumerable: true,
-  get: function () { return chunkAMGK7DDM_cjs.useTheme; }
+  get: function () { return chunkD4DQFTA7_cjs.useTheme; }
 });
 //# sourceMappingURL=ThemeProvider.cjs.map
 //# sourceMappingURL=ThemeProvider.cjs.map

package/dist/theme/ThemeProvider.d.cts

@@ -31,10 +31,10 @@ declare function createTailwindTheme(theme: Partial<ThemeTokens>): TailwindTheme
 
 /**
  * Canonical default theme token values. `defaults.css` mirrors these exactly.
- * Palette is a neutral monochrome (ElevenLabs-like) so the SDK is brand-neutral
- * out of the box; consumers rebrand via `ThemeProvider`. All colour pairs are
- * verified to meet WCAG 2.2 AA: 4.5:1 for normal text, 3:1 for UI / focus ring
- * (see theme/__tests__/contrast.test.ts).
+ * Palette is a neutral monochrome, deliberately unbranded, so the SDK carries
+ * nobody's look out of the box; consumers rebrand via `ThemeProvider`. All
+ * colour pairs are verified to meet WCAG 2.2 AA: 4.5:1 for normal text, 3:1 for
+ * UI / focus ring (see theme/__tests__/contrast.test.ts).
  */
 declare const defaultTheme: ThemeTokens;