@intellectif/lk-react 23.1.0 → 23.1.1

package/dist/index-n9PKZm7W.d.cts

@@ -0,0 +1,291 @@
+import { t as LearnerAi } from "./LkAiProvider-DAPpA3PQ.cjs";
+import { a as RenderMode, l as SequenceRecordingBinding, n as HtmlSanitizer, s as RenderableActivity, u as SequenceRecordingSlot, v as LkStringsOverride, x as VideoPreferences } from "./types-BOQd93x3.cjs";
+import { ActivityResult, DeliveryPolicy, InteractionEvent, InteractionKind, ItemGroup, ItemOutcome, ItemScoringPolicy, LearnerResponse, MediaProgress, MediaTrack, ResolvedDeliveryPolicy, ResolvedItemScoringPolicy, SpeechAssessment, ThemeTokens } from "@intellectif/lk-core";
+import { ReactNode } from "react";
+//#region src/components/InteractiveVideo/InteractiveVideo.d.ts
+/** An item group whose items may be `redact()` projections: the client's view of an interactive video. */
+type RenderableItemGroup = ItemGroup<RenderableActivity>;
+/** A question's place: its slot, as `<ActivitySequence>` reports it, plus the quiz it sits in. */
+interface InteractiveVideoSlot extends SequenceRecordingSlot {
+  cueId: string;
+}
+/** What `onFinished` reports: every question, and how the learner left it. */
+interface InteractiveVideoSummary {
+  slots: {
+    slotId: string;
+    activityId: string;
+    cueId: string;
+    status: 'answered' | 'skipped' | 'unreached';
+  }[];
+}
+/**
+ * One question, as `renderQuestion` is handed it: what to draw, and the six
+ * calls through which the video learns what the learner did.
+ *
+ * The calls are the ones the SDK's own components make, so a question the host
+ * draws counts exactly as one the SDK draws — in the step dots, in whether a
+ * required quiz lets the learner go on, on the end card and in `onFinished`.
+ * Each keeps ONE identity per question for the life of the player, so it is
+ * safe in an effect's dependencies, and each does nothing once the player has
+ * unmounted.
+ */
+interface InteractiveVideoQuestion {
+  /** The question, as the SDK would have rendered it: full data, or a `redact()` projection. */
+  activity: RenderableActivity;
+  /** Where it sits: the same object `onSubmit` and `onActivityComplete` are handed, for the life of the player. */
+  slot: InteractiveVideoSlot;
+  /**
+   * Passed through untouched. The SDK cannot enforce a mode for pixels it does
+   * not draw: in `exam` the host must not reveal correctness, and in `review`
+   * nothing is submittable — `submit`, `complete` and `clear` are ignored there.
+   */
+  renderMode: RenderMode;
+  /**
+   * `true` while this question is the one on screen: its quiz is open and it is
+   * the current step. `false` from the moment it leaves the screen — another
+   * step, the quiz closing, another quiz opening — and `true` again when the
+   * learner comes back.
+   *
+   * WHEN IT TURNS `false`, STOP THE MICROPHONE, ANY TIMER AND ANY SPEECH. The
+   * video pauses the `<audio>` and `<video>` elements inside the question and
+   * stops the recorders the SDK started, but it cannot reach a recorder it did
+   * not create.
+   */
+  active: boolean;
+  locale?: string;
+  /** The answer restored from `responses`. A starting value: read it once, as the SDK's components do. */
+  defaultValue?: LearnerResponse;
+  /** Whether `submittedSlotIds` names this question: it was handed in before this attempt resumed. */
+  defaultSubmitted: boolean;
+  /** Its stored outcome from `outcomes`: review, or the grade of a question graded later. Read live. */
+  outcome?: ItemOutcome;
+  /**
+   * An element inside the player, for popovers and tooltips. Portal into it
+   * rather than into `document.body`: in fullscreen only the player is painted,
+   * and anything outside it silently vanishes. It is drawn above the quiz, is
+   * the same element for the life of the player — one for every question, so
+   * key what you put in it — and is `null` only before the player's first
+   * commit.
+   */
+  portalContainer: HTMLElement | null;
+  /**
+   * The AI ports in force for this video — its `ai` prop, else an
+   * `LkAiProvider` above it — for a host that offers its own explanations or
+   * hints. Absent in `exam`: no question gives AI help there, and the SDK
+   * hands its ports to none.
+   */
+  ai?: LearnerAi;
+  /**
+   * The video's delivery policy, every setting spelled out: what this question
+   * may show. The SDK cannot keep a policy in pixels it does not draw — where
+   * `feedback` or `solutions` is `false`, show no mark and no answer.
+   */
+  delivery: ResolvedDeliveryPolicy;
+  /**
+   * The video's scoring policy, every setting spelled out: how many tries a
+   * question gives, which counts, and what tries and hints cost. The SDK's own
+   * questions apply it; a question you draw scores by it with lk-core's
+   * `scoreTries`, or not at all.
+   */
+  scoring: ResolvedItemScoringPolicy;
+  /**
+   * The learner committed an answer: marks the question answered and forwards
+   * to `onSubmit(response, slot)`. Latest wins: call it again for a new take or
+   * a corrected answer.
+   */
+  submit(response: LearnerResponse): void;
+  /**
+   * The answer has a result: marks the question answered, keeps `score / maxScore`
+   * for the end card when `maxScore > 0`, and forwards to
+   * `onActivityComplete(result, slot)`. Latest wins. Counts as answered on its
+   * own, without a `submit`, and forwards exactly what was called — no
+   * `onSubmit` is invented for it.
+   */
+  complete(result: ActivityResult): void;
+  /**
+   * The learner withdrew the answer — a "Try again". The question is unanswered
+   * again and its score forgotten: its step dot empties, a required quiz holds
+   * the learner again, and `onFinished` would report it `skipped`. Calls no
+   * host callback: the host already knows.
+   */
+  clear(): void;
+  /**
+   * Work is on its way for this question — an upload, an assessment. While any
+   * question is pending, Finish on the end card waits, and a video that ends
+   * does not finish by itself; closing the quiz, paging and seeking do not wait.
+   * Call `setPending(false)` however the work ends, a failure included.
+   */
+  setPending(pending: boolean): void;
+  /** Forwards to `onInteraction`, with this question's `activityId` and the time filled in. */
+  emit(type: InteractionKind, payload?: Record<string, unknown>): void;
+}
+interface InteractiveVideoProps {
+  /** An item group with a video stimulus and a timeline. Redacted projections in exam and review. */
+  group: RenderableItemGroup;
+  /**
+   * `practice` (the default) grades each question and shows its feedback;
+   * `exam` submits without showing correctness — a check-in marked later;
+   * `review` shows how each question was marked.
+   *
+   * `exam` does NOT make the video fit for an official summative exam. The
+   * learner controls the recording — rewinds it, slows it, reads its
+   * transcript — while the questions are open, and nothing here times a
+   * question or holds a single pass. Deliver a paper of record with
+   * `<ActivitySequence>`.
+   */
+  renderMode?: RenderMode;
+  /** Where to resume. Read through `readMediaProgress` and clamped; a required quiz is never skipped by a resume. */
+  progress?: MediaProgress;
+  /** At most every 5 s while playing, and on pause, seek, a quiz opening and the end. */
+  onProgress?: (progress: MediaProgress) => void;
+  /** Answers restored from the host, by slot id: `AttemptState.responses`. Read once, at mount. */
+  responses?: Readonly<Record<string, LearnerResponse>>;
+  /**
+   * Questions the learner had already submitted, from
+   * `AttemptState.submittedSlotIds`: mounted submitted, and counted as
+   * answered, so a resumed video neither reopens a committed answer nor stops
+   * again at a quiz already done. Read once, at mount.
+   */
+  submittedSlotIds?: readonly string[];
+  /** Stored outcomes, by slot id: review, and the grades of questions graded later. */
+  outcomes?: Readonly<Record<string, ItemOutcome>>;
+  onSubmit?: (response: LearnerResponse, slot: InteractiveVideoSlot) => void;
+  onActivityComplete?: (result: ActivityResult, slot: InteractiveVideoSlot) => void;
+  /**
+   * Once per mount: when the learner presses Finish, or the video ends with every
+   * question answered — either way, only once no answer is still on its way.
+   */
+  onFinished?: (summary: InteractiveVideoSummary) => void;
+  onInteraction?: (event: InteractionEvent) => void;
+  /**
+   * Draws a question yourself. Called for each question once its quiz has
+   * opened, and on every render after;
+   * return `undefined` for the SDK's own component, so a host can take over one
+   * activity type and leave the rest. `null` draws nothing, and is kept.
+   *
+   * The video still owns everything around the question: when it opens,
+   * whether it counts as answered, whether a required quiz lets the learner go
+   * on, pausing, resume and the end summary — all through the calls on
+   * {@link InteractiveVideoQuestion}. A question the host draws is never
+   * treated differently from one the SDK draws.
+   *
+   * THE HOST MUST STOP ITS MICROPHONE WHEN `active` TURNS `false`: the SDK stops
+   * only the recorders it created. And the SDK cannot keep a mode for pixels it
+   * does not draw: in `exam` reveal no correctness, and in `review` accept no
+   * answer.
+   *
+   * What you return is keyed by the question's slot and stays mounted for the
+   * life of the player, like the SDK's own questions, and sits inside the same
+   * error boundary: a throw degrades that one question, never the video.
+   */
+  renderQuestion?: (question: InteractiveVideoQuestion) => ReactNode | undefined;
+  /**
+   * Where read-aloud takes are stored and judged. Required for every read-aloud
+   * the SDK draws itself, outside review; a video whose read-alouds are all
+   * drawn by `renderQuestion` needs none.
+   */
+  recordingBinding?: SequenceRecordingBinding;
+  /** Speech assessments by slot id, so `review` shows the marks behind a read-aloud's grade. Read live. */
+  assessments?: Readonly<Record<string, SpeechAssessment>>;
+  /** A self-hosted copy of the read-aloud capture processor, for a strict Content-Security-Policy. */
+  workletUrl?: string;
+  /**
+   * Fetches a caption file with the host's credentials and returns its WebVTT
+   * text. Without it, the player fetches `src` itself — which a `<track>`
+   * could not do for a URL that needs an Authorization header.
+   */
+  captionsLoader?: (track: MediaTrack) => Promise<string>;
+  /**
+   * FORCES preferences: each field given here overrides what the learner chose,
+   * every time the video opens. For a starting point the learner can still
+   * change — a language pair, say — pass `defaultPreferences` instead. Read when
+   * the video opens; the learner's own changes after that hold.
+   */
+  preferences?: Partial<VideoPreferences>;
+  /**
+   * Preferences to start from, below what the learner chose in this browser:
+   * each field applies until the learner changes it. A host that keeps the
+   * learner's choice on their account passes it back here — on a new device
+   * nothing is stored, so the account's choice applies; on the same device the
+   * stored choice is that same choice. Read live: a value that arrives after
+   * the video opens still fills every field nobody chose.
+   */
+  defaultPreferences?: Partial<VideoPreferences>;
+  /**
+   * After each change the learner makes — a menu, a shortcut, the volume, the
+   * speed — with the preferences now in force and the fields that changed.
+   * Never when the video opens, and never for `preferences`. The player still
+   * remembers the change in this browser; this is for a host that keeps it on
+   * the learner's account as well.
+   */
+  onPreferencesChange?: (next: VideoPreferences, change: Partial<VideoPreferences>) => void;
+  /** A short label in the corner, such as a lesson code. */
+  label?: string;
+  /** Seed for the option order of multiple-choice and gap-select questions: the attempt id. */
+  shuffleSeed?: string;
+  locale?: string;
+  strings?: LkStringsOverride;
+  /**
+   * The host's AI ports, for every question the SDK draws: explanations after
+   * grading, hints before submit. The same as `LkAiProvider`, for this one
+   * video. Nothing AI appears in `exam`. See {@link LearnerAi}.
+   */
+  ai?: LearnerAi;
+  /**
+   * What a learner may see around the video's questions — feedback,
+   * solutions, hints, AI help — for every question in it, and on the end card:
+   * with `feedback: false` it counts answers and shows no score. Each setting
+   * only takes away. See `DeliveryPolicy` in lk-core.
+   */
+  delivery?: DeliveryPolicy | null;
+  /**
+   * How the video's questions are scored when a learner can try again or ask
+   * for hints — for every question in it. A later try replaces a question's
+   * grade, as any answer given again does, until the learner finishes: then
+   * every question's tries close. See `ItemScoringPolicy` in lk-core.
+   *
+   * A policy `validateItemScoringPolicy` refuses throws at render.
+   */
+  scoring?: ItemScoringPolicy | null;
+  theme?: Partial<ThemeTokens>;
+  sanitizeHtml?: HtmlSanitizer;
+}
+//#endregion
+//#region src/components/InteractiveVideo/tracks.d.ts
+/** The two lines a learner can have: which track each shows, if any. */
+interface CaptionTracks {
+  primary?: MediaTrack;
+  secondary?: MediaTrack;
+}
+/**
+ * Which track each caption line shows, from the learner's two choices.
+ *
+ * The primary line always shows something while there are tracks:
+ * 1. the track in `captionLanguage` (case-insensitive);
+ * 2. else one of the same primary language — `pt` finds `pt-BR`, `es` finds
+ *    `es-419`;
+ * 3. else the `default` track;
+ * 4. else the first.
+ *
+ * Where two tracks share a language, the `captions` one wins.
+ *
+ * The secondary line is stricter: it appears only when `secondaryCaptionLanguage`
+ * is set and matches a track in another language, by steps 1 and 2 alone —
+ * never the default, never the first. A second line the learner did not choose
+ * must never appear.
+ */
+declare function resolveCaptionTracks(tracks: readonly MediaTrack[], preferences: Pick<VideoPreferences, 'captionLanguage' | 'secondaryCaptionLanguage'>): CaptionTracks;
+//#endregion
+//#region src/components/InteractiveVideo/index.d.ts
+/**
+ * Public interactive video: the player wrapped in `ActivityErrorBoundary`, so a
+ * render failure — the development-time schema check among them — degrades to
+ * an accessible fallback instead of taking the host page down.
+ *
+ * A formative tool, for lessons and practice — not for official summative
+ * exams, which `<ActivitySequence>` delivers.
+ */
+declare function InteractiveVideo(props: InteractiveVideoProps): import("react/jsx-runtime").JSX.Element;
+//#endregion
+export { InteractiveVideoQuestion as a, RenderableItemGroup as c, InteractiveVideoProps as i, CaptionTracks as n, InteractiveVideoSlot as o, resolveCaptionTracks as r, InteractiveVideoSummary as s, InteractiveVideo as t };
+//# sourceMappingURL=index-n9PKZm7W.d.cts.map

package/dist/index-n9PKZm7W.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index-n9PKZm7W.d.cts","names":[],"sources":["../src/components/InteractiveVideo/InteractiveVideo.tsx","../src/components/InteractiveVideo/tracks.ts","../src/components/InteractiveVideo/index.tsx"],"mappings":";;;;;;KAsGY,sBAAsB,UAAU;;UAG3B,6BAA6B;EAC5C;;;UAIe;EACf;IACE;IACA;IACA;IACA;;;;;;;;;;;;;;UAea;;EAEf,UAAU;;EAEV,MAAM;;;;;;EAMN,YAAY;;;;;;;;;;;;EAYZ;EACA;;EAEA,eAAe;;EAEf;;EAEA,UAAU;;;;;;;;;EASV,iBAAiB;;;;;;;EAOjB,KAAK;;;;;;EAML,UAAU;;;;;;;EAOV,SAAS;;;;;;EAMT,OAAO,UAAU;;;;;;;;EAQjB,SAAS,QAAQ;;;;;;;EAOjB;;;;;;;EAOA,WAAW;;EAEX,KAAK,MAAM,iBAAiB,UAAU;;UAGvB;;EAEf,OAAO;;;;;;;;;;;;EAYP,aAAa;;EAEb,WAAW;;EAEX,cAAc,UAAU;;EAExB,YAAY,SAAS,eAAe;;;;;;;EAOpC;;EAEA,WAAW,SAAS,eAAe;EACnC,YAAY,UAAU,iBAAiB,MAAM;EAC7C,sBAAsB,QAAQ,gBAAgB,MAAM;;;;;EAKpD,cAAc,SAAS;EACvB,iBAAiB,OAAO;;;;;;;;;;;;;;;;;;;;;;EAsBxB,kBAAkB,UAAU,6BAA6B;;;;;;EAMzD,mBAAmB;;EAEnB,cAAc,SAAS,eAAe;;EAEtC;;;;;;EAMA,kBAAkB,OAAO,eAAe;;;;;;;EAOxC,cAAc,QAAQ;;;;;;;;;EAStB,qBAAqB,QAAQ;;;;;;;;EAQ7B,uBAAuB,MAAM,kBAAkB,QAAQ,QAAQ;;EAE/D;;EAEA;EACA;EACA,UAAU;;;;;;EAMV,KAAK;;;;;;;EAOL,WAAW;;;;;;;;;EASX,UAAU;EACV,QAAQ,QAAQ;EAChB,eAAe;;;;;UCzVA;EACf,UAAU;EACV,YAAY;;;;;;;;;;;;;;;;;;;iBAyDE,qBACd,iBAAiB,cACjB,aAAa,KAAK,oEACjB;;;;;;;;;;;iBCtCa,iBAAiB,OAAO,oDAAqB,IAAA"}

package/dist/index-zu9H7owf.d.ts

@@ -0,0 +1,24 @@
+import { t as ActivityProps } from "./types-HIrgF_mS.js";
+import { MultipleChoiceData } from "@intellectif/lk-core";
+//#region src/components/MultipleChoice/MultipleChoice.d.ts
+interface MultipleChoiceProps extends ActivityProps<MultipleChoiceData> {
+  /**
+   * Seed for the deterministic option shuffle. Supply one (e.g. the attempt
+   * id) to make the shuffled order reproducible server-side, stable across
+   * page reloads, and identical between SSR and hydration. When absent, a
+   * random per-mount session seed is used (order stable within the mount
+   * only — the behaviour before `shuffleSeed` existed).
+   */
+  shuffleSeed?: string;
+}
+//#endregion
+//#region src/components/MultipleChoice/index.d.ts
+/**
+ * Public Multiple Choice activity: the core component wrapped in
+ * `ActivityErrorBoundary` so a render failure (incl. the dev schema-validation
+ * throw) degrades to an accessible fallback instead of crashing the host.
+ */
+declare function MultipleChoice(props: MultipleChoiceProps): import("react/jsx-runtime").JSX.Element;
+//#endregion
+export { MultipleChoiceProps as n, MultipleChoice as t };
+//# sourceMappingURL=index-zu9H7owf.d.ts.map

package/dist/index-zu9H7owf.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index-zu9H7owf.d.ts","names":[],"sources":["../src/components/MultipleChoice/MultipleChoice.tsx","../src/components/MultipleChoice/index.tsx"],"mappings":";;;UAyGiB,4BAA4B,cAAc;;;;;;;;EAQzD;;;;;;;;;iBCjGc,eAAe,OAAO,kDAAmB,IAAA"}

package/dist/index.cjs

@@ -1,171 +1,126 @@
 'use client';
-'use strict';
-
-var chunkPNNUPUH4_cjs = require('./chunk-PNNUPUH4.cjs');
-var chunkK63VPFOV_cjs = require('./chunk-K63VPFOV.cjs');
-var chunkCWTUWNV3_cjs = require('./chunk-CWTUWNV3.cjs');
-var chunkV6BA44DS_cjs = require('./chunk-V6BA44DS.cjs');
-var chunkKFLIDTDU_cjs = require('./chunk-KFLIDTDU.cjs');
-var chunkRPWUDXG5_cjs = require('./chunk-RPWUDXG5.cjs');
-var chunkMKXEM2C5_cjs = require('./chunk-MKXEM2C5.cjs');
-var chunkYY4PFR3Z_cjs = require('./chunk-YY4PFR3Z.cjs');
-var chunkDS6HN3YR_cjs = require('./chunk-DS6HN3YR.cjs');
-var chunk7ALBSPYR_cjs = require('./chunk-7ALBSPYR.cjs');
-var chunkNAK55BYU_cjs = require('./chunk-NAK55BYU.cjs');
-require('./chunk-KHKH5LCT.cjs');
-var chunkTP5UMRAU_cjs = require('./chunk-TP5UMRAU.cjs');
-var chunkLBEKRN6Y_cjs = require('./chunk-LBEKRN6Y.cjs');
-var chunkUDCQTOVU_cjs = require('./chunk-UDCQTOVU.cjs');
-require('./chunk-OD65OZIW.cjs');
-require('./chunk-2PNSVBLQ.cjs');
-require('./chunk-J3C72RPK.cjs');
-var chunkLPUWXIPR_cjs = require('./chunk-LPUWXIPR.cjs');
-require('./chunk-NDBMKGQ5.cjs');
-var chunkXOR4MPEN_cjs = require('./chunk-XOR4MPEN.cjs');
-var chunkBIGGXHAW_cjs = require('./chunk-BIGGXHAW.cjs');
-var chunkTUVENMXB_cjs = require('./chunk-TUVENMXB.cjs');
-
-// src/components/types.ts
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_ai_LkAiProvider = require("./ai/LkAiProvider.cjs");
+const require_useAiHelp = require("./useAiHelp-h9yOLFqt.cjs");
+const require_LkIntlProvider = require("./LkIntlProvider-oi57lYB0.cjs");
+const require_hooks_useActivityState = require("./hooks/useActivityState.cjs");
+const require_Dictation = require("./Dictation-jECzL88E.cjs");
+const require_FillInTheBlanks = require("./FillInTheBlanks-BpKhdHg2.cjs");
+const require_GapSelect = require("./GapSelect-payTq_Zn.cjs");
+const require_MultipleChoice = require("./MultipleChoice-COn5MtKY.cjs");
+const require_useSpeechRecorder = require("./useSpeechRecorder--O_f-xvt.cjs");
+const require_PronunciationFeedback = require("./PronunciationFeedback-DlMPGjkR.cjs");
+const require_ReadAloud = require("./ReadAloud-akDehitT.cjs");
+const require_WrittenResponse = require("./WrittenResponse-Bj3eFmGl.cjs");
+const require_ActivityPreview = require("./ActivityPreview-BKr34exz.cjs");
+const require_StimulusPanel = require("./StimulusPanel-b66gaN3i.cjs");
+const require_ActivitySequence = require("./ActivitySequence-CmoSyDnp.cjs");
+const require_InteractiveVideo = require("./InteractiveVideo-BguGv-HA.cjs");
+const require_hooks_useXAPI = require("./hooks/useXAPI.cjs");
+const require_ThemeProvider = require("./ThemeProvider-BRN1tj4n.cjs");
+//#region src/components/types.ts
+/**
+* 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.
+*/
 function asRenderable(redacted) {
-  return redacted;
+	return redacted;
 }
+/**
+* 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.
+*/
 function asRenderableSequence(entries) {
-  return entries;
+	return entries;
 }
-
-Object.defineProperty(exports, "useXAPI", {
-  enumerable: true,
-  get: function () { return chunkPNNUPUH4_cjs.useXAPI; }
-});
-Object.defineProperty(exports, "ThemeProvider", {
-  enumerable: true,
-  get: function () { return chunkK63VPFOV_cjs.ThemeProvider; }
-});
-Object.defineProperty(exports, "createTailwindTheme", {
-  enumerable: true,
-  get: function () { return chunkK63VPFOV_cjs.createTailwindTheme; }
-});
-Object.defineProperty(exports, "darkTheme", {
-  enumerable: true,
-  get: function () { return chunkK63VPFOV_cjs.darkTheme; }
-});
-Object.defineProperty(exports, "defaultTheme", {
-  enumerable: true,
-  get: function () { return chunkK63VPFOV_cjs.defaultTheme; }
-});
-Object.defineProperty(exports, "useTheme", {
-  enumerable: true,
-  get: function () { return chunkK63VPFOV_cjs.useTheme; }
-});
-Object.defineProperty(exports, "InteractiveVideo", {
-  enumerable: true,
-  get: function () { return chunkCWTUWNV3_cjs.InteractiveVideo; }
-});
-Object.defineProperty(exports, "resolveCaptionTracks", {
-  enumerable: true,
-  get: function () { return chunkCWTUWNV3_cjs.resolveCaptionTracks; }
-});
-Object.defineProperty(exports, "ActivityPreview", {
-  enumerable: true,
-  get: function () { return chunkV6BA44DS_cjs.ActivityPreview; }
-});
-Object.defineProperty(exports, "ActivitySequence", {
-  enumerable: true,
-  get: function () { return chunkKFLIDTDU_cjs.ActivitySequence; }
-});
-Object.defineProperty(exports, "StimulusPanel", {
-  enumerable: true,
-  get: function () { return chunkRPWUDXG5_cjs.StimulusPanel; }
-});
-Object.defineProperty(exports, "WrittenResponse", {
-  enumerable: true,
-  get: function () { return chunkMKXEM2C5_cjs.WrittenResponse; }
-});
-Object.defineProperty(exports, "MultipleChoice", {
-  enumerable: true,
-  get: function () { return chunkYY4PFR3Z_cjs.MultipleChoice; }
-});
-Object.defineProperty(exports, "FillInTheBlanks", {
-  enumerable: true,
-  get: function () { return chunkDS6HN3YR_cjs.FillInTheBlanks; }
-});
-Object.defineProperty(exports, "GapSelect", {
-  enumerable: true,
-  get: function () { return chunk7ALBSPYR_cjs.GapSelect; }
-});
-Object.defineProperty(exports, "Dictation", {
-  enumerable: true,
-  get: function () { return chunkNAK55BYU_cjs.Dictation; }
-});
-Object.defineProperty(exports, "ReadAloud", {
-  enumerable: true,
-  get: function () { return chunkTP5UMRAU_cjs.ReadAloud; }
-});
-Object.defineProperty(exports, "PronunciationFeedback", {
-  enumerable: true,
-  get: function () { return chunkLBEKRN6Y_cjs.PronunciationFeedback; }
-});
-Object.defineProperty(exports, "CAPTURE_PROCESSOR_SOURCE", {
-  enumerable: true,
-  get: function () { return chunkUDCQTOVU_cjs.CAPTURE_PROCESSOR_SOURCE; }
-});
-Object.defineProperty(exports, "useSpeechRecorder", {
-  enumerable: true,
-  get: function () { return chunkUDCQTOVU_cjs.useSpeechRecorder; }
-});
-Object.defineProperty(exports, "useAiCoaching", {
-  enumerable: true,
-  get: function () { return chunkLPUWXIPR_cjs.useAiCoaching; }
-});
-Object.defineProperty(exports, "useAiExplanation", {
-  enumerable: true,
-  get: function () { return chunkLPUWXIPR_cjs.useAiExplanation; }
-});
-Object.defineProperty(exports, "useAiHints", {
-  enumerable: true,
-  get: function () { return chunkLPUWXIPR_cjs.useAiHints; }
-});
-Object.defineProperty(exports, "useAiWritingFeedback", {
-  enumerable: true,
-  get: function () { return chunkLPUWXIPR_cjs.useAiWritingFeedback; }
-});
-Object.defineProperty(exports, "useActivityState", {
-  enumerable: true,
-  get: function () { return chunkXOR4MPEN_cjs.useActivityState; }
-});
-Object.defineProperty(exports, "DEFAULT_STRINGS", {
-  enumerable: true,
-  get: function () { return chunkBIGGXHAW_cjs.DEFAULT_STRINGS; }
-});
-Object.defineProperty(exports, "LkIntlProvider", {
-  enumerable: true,
-  get: function () { return chunkBIGGXHAW_cjs.LkIntlProvider; }
-});
-Object.defineProperty(exports, "directionForLocale", {
-  enumerable: true,
-  get: function () { return chunkBIGGXHAW_cjs.directionForLocale; }
-});
-Object.defineProperty(exports, "mergeStrings", {
-  enumerable: true,
-  get: function () { return chunkBIGGXHAW_cjs.mergeStrings; }
-});
-Object.defineProperty(exports, "useLkDirection", {
-  enumerable: true,
-  get: function () { return chunkBIGGXHAW_cjs.useLkDirection; }
-});
-Object.defineProperty(exports, "useLkStrings", {
-  enumerable: true,
-  get: function () { return chunkBIGGXHAW_cjs.useLkStrings; }
-});
-Object.defineProperty(exports, "LkAiProvider", {
-  enumerable: true,
-  get: function () { return chunkTUVENMXB_cjs.LkAiProvider; }
-});
-Object.defineProperty(exports, "useLearnerAi", {
-  enumerable: true,
-  get: function () { return chunkTUVENMXB_cjs.useLearnerAi; }
-});
+//#endregion
+exports.ActivityPreview = require_ActivityPreview.ActivityPreview;
+exports.ActivitySequence = require_ActivitySequence.ActivitySequence;
+exports.CAPTURE_PROCESSOR_SOURCE = require_useSpeechRecorder.CAPTURE_PROCESSOR_SOURCE;
+exports.DEFAULT_STRINGS = require_LkIntlProvider.DEFAULT_STRINGS;
+exports.Dictation = require_Dictation.Dictation;
+exports.FillInTheBlanks = require_FillInTheBlanks.FillInTheBlanks;
+exports.GapSelect = require_GapSelect.GapSelect;
+exports.InteractiveVideo = require_InteractiveVideo.InteractiveVideo;
+exports.LkAiProvider = require_ai_LkAiProvider.LkAiProvider;
+exports.LkIntlProvider = require_LkIntlProvider.LkIntlProvider;
+exports.MultipleChoice = require_MultipleChoice.MultipleChoice;
+exports.PronunciationFeedback = require_PronunciationFeedback.PronunciationFeedback;
+exports.ReadAloud = require_ReadAloud.ReadAloud;
+exports.StimulusPanel = require_StimulusPanel.StimulusPanel;
+exports.ThemeProvider = require_ThemeProvider.ThemeProvider;
+exports.WrittenResponse = require_WrittenResponse.WrittenResponse;
 exports.asRenderable = asRenderable;
 exports.asRenderableSequence = asRenderableSequence;
-//# sourceMappingURL=index.cjs.map
+exports.createTailwindTheme = require_ThemeProvider.createTailwindTheme;
+exports.darkTheme = require_ThemeProvider.darkTheme;
+exports.defaultTheme = require_ThemeProvider.defaultTheme;
+exports.directionForLocale = require_LkIntlProvider.directionForLocale;
+exports.mergeStrings = require_LkIntlProvider.mergeStrings;
+exports.resolveCaptionTracks = require_InteractiveVideo.resolveCaptionTracks;
+exports.useActivityState = require_hooks_useActivityState.useActivityState;
+exports.useAiCoaching = require_useAiHelp.useAiCoaching;
+exports.useAiExplanation = require_useAiHelp.useAiExplanation;
+exports.useAiHints = require_useAiHelp.useAiHints;
+exports.useAiWritingFeedback = require_useAiHelp.useAiWritingFeedback;
+exports.useLearnerAi = require_ai_LkAiProvider.useLearnerAi;
+exports.useLkDirection = require_LkIntlProvider.useLkDirection;
+exports.useLkStrings = require_LkIntlProvider.useLkStrings;
+exports.useSpeechRecorder = require_useSpeechRecorder.useSpeechRecorder;
+exports.useTheme = require_ThemeProvider.useTheme;
+exports.useXAPI = require_hooks_useXAPI.useXAPI;
+
 //# sourceMappingURL=index.cjs.map