@intellectif/lk-react 23.1.0 → 23.1.2

package/dist/index-CSsuUsP7.d.cts

@@ -0,0 +1,124 @@
+import { t as LearnerAi } from "./LkAiProvider-DAPpA3PQ.cjs";
+import { a as RenderMode, i as MediaTransportStrings, n as HtmlSanitizer, o as Renderable, r as MediaBudgetBinding, v as LkStringsOverride } from "./types-BOQd93x3.cjs";
+import { DeliveryPolicy, InteractionEvent, ItemOutcome, LearnerResponse, ThemeTokens, WrittenResponseData, XAPIStatement } from "@intellectif/lk-core";
+//#region src/components/WrittenResponse/WrittenResponse.d.ts
+/**
+ * Payload delivered when the learner submits a written response. Grading is
+ * DEFERRED (asynchronous AI/human grading), so there is no score here — and
+ * deliberately no fake one: an ungraded submission must never be shown or
+ * stored as a 0. The consumer persists `text` and grades it out-of-band.
+ */
+interface WrittenResponseSubmission {
+  /** The submitted text, verbatim. */
+  text: string;
+  /** Word count of `text`, recomputed with the canonical `countWords()`. */
+  wordCount: number;
+  /** Whether `wordCount` falls within the activity's `[minWords, maxWords]`. */
+  withinWordBounds: boolean;
+  /** Time in milliseconds from first interaction to submission. */
+  timeSpent: number;
+  /** The SUBMITTED-verb xAPI statement built for this submission (no score fields). */
+  xapiStatement: XAPIStatement;
+}
+/**
+ * Props for {@link WrittenResponse}. Mirrors `ActivityProps` except for the
+ * completion callback: a deferred-grading activity completes with a
+ * {@link WrittenResponseSubmission} (`onSubmitted`), not a scored
+ * `ActivityResult` (`onComplete`), on purpose: fabricating a score of 0 for
+ * ungraded work is the exact bug this type exists to fix. Everything else — controlled value, render
+ * mode, server outcome, rich text — follows the shared `ActivityProps`
+ * contract verbatim.
+ */
+interface WrittenResponseProps {
+  /** Activity content. Accepts a `redact()` projection in `exam` mode. */
+  data: Renderable<WrittenResponseData>;
+  /**
+   * Called on submit with the ungraded submission (text, recomputed word
+   * count, bounds flag, timing, xAPI statement). Fires in `practice` and
+   * `exam` mode, after `onSubmit`; never in `review`.
+   *
+   * Optional since lk-react 2.1.0 so a `review`-mode render (which has no submit
+   * control) and an exam runner that only wants the raw response through
+   * `onSubmit` do not have to pass a no-op. Supply it in `practice`/`exam`
+   * unless `onSubmit` already captures everything you persist.
+   */
+  onSubmitted?: (submission: WrittenResponseSubmission) => void;
+  /**
+   * Called on submit with the raw learner response and no grade, BEFORE
+   * `onSubmitted`. This is the only submit callback an exam runner needs:
+   * the server grades the text and returns an {@link ItemOutcome} later.
+   */
+  onSubmit?: (response: LearnerResponse) => void;
+  /**
+   * Controlled value: the learner's current response. When present the
+   * textarea renders from it (never from internal state) and every keystroke
+   * goes out through `onChange` — restore an in-progress attempt, autosave a
+   * delta, or drive a review render with it.
+   */
+  value?: LearnerResponse;
+  /** Initial response for an uncontrolled component (ignored when `value` is set). */
+  defaultValue?: LearnerResponse;
+  /**
+   * Mount as already submitted — read at mount only. Without it a resumed
+   * attempt reopens an essay the learner had already submitted as editable
+   * and re-submittable.
+   */
+  defaultSubmitted?: boolean;
+  /** Fires on every change to the learner's response. Required for a controlled component. */
+  onChange?: (response: LearnerResponse) => void;
+  /**
+   * Presentation mode, default `practice`. `practice` and `exam` are nearly
+   * identical here — a written response is never graded client-side, so
+   * there is no local score to withhold; `exam` additionally never calls
+   * `evaluate()` and renders happily from a `redact()` projection.
+   * `review` is read-only and shows the server's `outcome`.
+   */
+  renderMode?: RenderMode;
+  /**
+   * Server-computed outcome, rendered by `review` mode: `deferred` shows a
+   * "not graded yet" affordance, `scored` shows the returned grade and
+   * feedback. Ignored in other modes — this component never manufactures an
+   * outcome of its own.
+   */
+  outcome?: ItemOutcome;
+  /** Renders `data.promptHtml` when provided. See `HtmlSanitizer`. */
+  sanitizeHtml?: HtmlSanitizer;
+  /** Binds this activity's own `data.media` to a play budget. See {@link MediaBudgetBinding}. */
+  mediaBudget?: MediaBudgetBinding;
+  /** Translations for the audio transport chrome. See {@link MediaTransportStrings}. */
+  mediaStrings?: Partial<MediaTransportStrings>;
+  /** Overrides the SDK's chrome text for this activity. See {@link LkIntlProvider}. */
+  strings?: LkStringsOverride;
+  onInteraction?: (event: InteractionEvent) => void;
+  /** Per-instance token overrides, applied as inline CSS vars on the root. */
+  theme?: Partial<ThemeTokens>;
+  locale?: string;
+  disabled?: boolean;
+  /**
+   * The delivery policy. An essay is graded later, so `feedback` reaches it —
+   * `false` reads a returned grade back as nothing in `review` — and so does
+   * AI feedback on a draft, which needs `feedback`, `solutions` and
+   * `ai.explanations`. See `DeliveryPolicy` in lk-core.
+   */
+  delivery?: DeliveryPolicy | null;
+  /**
+   * The host's AI ports, overriding `LkAiProvider`'s. With a `writingFeedback`
+   * port, a learner in `practice` can ask for feedback on a draft before
+   * submitting it — up to `maxWritingFeedback` times — and revise. Every
+   * correction in it quotes the learner's own words, or the SDK refuses it.
+   * Never in `exam` or `review`. See {@link LearnerAi}.
+   */
+  ai?: LearnerAi;
+}
+//#endregion
+//#region src/components/WrittenResponse/index.d.ts
+/**
+ * Public Written Response activity: a labelled textarea with a live word
+ * counter for free-text writing graded asynchronously (AI or human). The core
+ * is wrapped in `ActivityErrorBoundary` so a render failure (incl. the dev
+ * schema-validation throw) degrades to an accessible fallback.
+ */
+declare function WrittenResponse(props: WrittenResponseProps): React.JSX.Element;
+//#endregion
+export { WrittenResponseProps as n, WrittenResponseSubmission as r, WrittenResponse as t };
+//# sourceMappingURL=index-CSsuUsP7.d.cts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index-CSsuUsP7.d.cts","names":[],"sources":["../src/components/WrittenResponse/WrittenResponse.tsx","../src/components/WrittenResponse/index.tsx"],"mappings":";;;;;;;;;;UA2CiB;;EAEf;;EAEA;;EAEA;;EAEA;;EAEA,eAAe;;;;;;;;;;;UAYA;;EAEf,MAAM,WAAW;;;;;;;;;;;EAWjB,eAAe,YAAY;;;;;;EAM3B,YAAY,UAAU;;;;;;;EAOtB,QAAQ;;EAER,eAAe;;;;;;EAMf;;EAEA,YAAY,UAAU;;;;;;;;EAQtB,aAAa;;;;;;;EAOb,UAAU;;EAEV,eAAe;;EAEf,cAAc;;EAEd,eAAe,QAAQ;;EAEvB,UAAU;EACV,iBAAiB,OAAO;;EAExB,QAAQ,QAAQ;EAChB;EACA;;;;;;;EAOA,WAAW;;;;;;;;EAQX,KAAK;;;;;;;;;;iBC9HS,gBAAgB,OAAO,uBAAuB,MAAM,IAAI"}

package/dist/index-CunUyeuN.d.cts

@@ -0,0 +1,78 @@
+import { a as RenderMode, n as HtmlSanitizer, v as LkStringsOverride } from "./types-BOQd93x3.cjs";
+import { t as ActivityRenderer } from "./index-6P4rJHrJ.cjs";
+import { DraftNotComplete, ItemOutcome, LearnerResponse, ThemeTokens } from "@intellectif/lk-core";
+import { ReactNode } from "react";
+//#region src/components/ActivityPreview/ActivityPreview.d.ts
+interface ActivityPreviewProps {
+  /**
+   * The activity as an editor holds it right now, finished or not. It is checked
+   * with `validateDraft` before anything renders — by content, on every render —
+   * so a half-written question never reaches a component that assumes a valid
+   * one.
+   */
+  draft: unknown;
+  /** The mode to preview in. Defaults to `practice`. */
+  renderMode?: RenderMode;
+  /**
+   * A learner response to show as if a learner had given it. In `practice` and
+   * `exam` it seeds the answer, which stays editable; in `review` it is the
+   * submitted answer, marked by `evaluate()` unless `outcome` is given.
+   */
+  response?: LearnerResponse;
+  /**
+   * The outcome `review` marks the response with, instead of the one
+   * `evaluate()` computes — which is how to preview a returned grade on a written
+   * response, since the SDK cannot score one. Ignored in other modes.
+   */
+  outcome?: ItemOutcome;
+  /**
+   * Rendered in place of the activity while the draft is not complete, with the
+   * issues `validateDraft` found — so an editor can list them in its own words.
+   * The issue messages are English, and a preview that rendered them would put
+   * untranslatable text on screen. Without it, the preview shows the
+   * `previewIncomplete` or `previewInvalid` string.
+   */
+  fallback?: (result: DraftNotComplete) => ReactNode;
+  /**
+   * Renderers for activity types beyond the built-ins, keyed by `type`, as on
+   * `<ActivitySequence>`. An entry receives the shared prop contract and
+   * nothing else, so — like the shuffle seed below — the in-memory recording
+   * binding a previewed read-aloud is given does not reach one. Nor does the
+   * `question` a sequence hands a renderer: a preview is one question with no
+   * set around it, so there is no slot to report to and nothing to page away
+   * from. A renderer that uses it must treat it as optional, which its type
+   * already says.
+   */
+  renderers?: Readonly<Record<string, ActivityRenderer>>;
+  /**
+   * Seeds `<MultipleChoice>`'s option shuffle. Defaults to a fixed seed, so the
+   * order holds while options are edited; adding or removing one deals them
+   * again, because the shuffle orders by position. A `renderers` entry is given
+   * no seed, as on `<ActivitySequence>`.
+   */
+  shuffleSeed?: string;
+  /** Renders author-supplied rich text. See `HtmlSanitizer`. */
+  sanitizeHtml?: HtmlSanitizer;
+  /** Overrides the SDK's chrome text, for the preview's notice and the activity alike. */
+  strings?: LkStringsOverride;
+  /** Per-instance token overrides, passed to the activity. */
+  theme?: Partial<ThemeTokens>;
+  /** BCP 47 tag of the interface language, passed to the activity. */
+  locale?: string;
+}
+/**
+ * Renders an activity from an editor's draft, in any render mode, with a
+ * simulated learner response — and renders a notice instead while the draft is
+ * not an activity yet.
+ *
+ * Nothing it renders is recorded: no callback is wired, so a practice attempt in
+ * a preview scores locally and goes nowhere, and a recording's play limit is
+ * counted in memory only.
+ *
+ * A draft with no string `type`, a type nobody registered, and a `response` of a
+ * different type from the draft are wiring errors, and throw.
+ */
+declare function ActivityPreview({ draft, renderMode, response, outcome, fallback, renderers, shuffleSeed, sanitizeHtml, strings, theme, locale }: ActivityPreviewProps): React.JSX.Element;
+//#endregion
+export { ActivityPreviewProps as n, ActivityPreview as t };
+//# sourceMappingURL=index-CunUyeuN.d.cts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index-CunUyeuN.d.cts","names":[],"sources":["../src/components/ActivityPreview/ActivityPreview.tsx"],"mappings":";;;;;UAkEiB;;;;;;;EAOf;;EAEA,aAAa;;;;;;EAMb,WAAW;;;;;;EAMX,UAAU;;;;;;;;EAQV,YAAY,QAAQ,qBAAqB;;;;;;;;;;;EAWzC,YAAY,SAAS,eAAe;;;;;;;EAOpC;;EAEA,eAAe;;EAEf,UAAU;;EAEV,QAAQ,QAAQ;;EAEhB;;;;;;;;;;;;;;iBAiBc,kBACd,OACA,YACA,UACA,SACA,UACA,WACA,aACA,cACA,SACA,OACA,UACC,uBAAuB,MAAM,IAAI"}

package/dist/index-CzfRzks6.d.cts

@@ -0,0 +1,90 @@
+import { t as LearnerAi } from "./LkAiProvider-DAPpA3PQ.cjs";
+import { a as RenderMode, v as LkStringsOverride } from "./types-BOQd93x3.cjs";
+import { DeliveryPolicy, GradeRecord, InteractionEvent, ReadAloudData, SpeechAssessment, ThemeTokens } from "@intellectif/lk-core";
+import "react";
+//#region src/components/PronunciationFeedback/PronunciationFeedback.d.ts
+interface PronunciationFeedbackProps {
+  /**
+   * The item's reading and its language: the two fields every mark depends
+   * on. Pass the whole item — or its `id` and `title` with them, and its
+   * `instructions` and `ai` where it has them — for AI coaching: without an
+   * `id` and a `title` none is offered, whatever the ports.
+   */
+  data: Pick<ReadAloudData, 'referenceText' | 'locale'> & Partial<Pick<ReadAloudData, 'id' | 'title' | 'instructions' | 'ai'>>;
+  /**
+   * The assessor's evidence. Checked with `validateSpeechAssessment` before it
+   * is aligned: see the note on this component about what a bad one costs.
+   */
+  assessment: SpeechAssessment;
+  /**
+   * The grade the evidence produced, when one exists. Its `criteria` are what
+   * the dimensions are read from, because they are the numbers the learner was
+   * actually graded on. A grade that cannot be read — a score that is not a
+   * number between 0 and its maximum, a `passed` that is not a boolean — is
+   * shown as could-not-be-graded, never as a percentage made up from it.
+   */
+  grade?: GradeRecord;
+  /**
+   * The learner's own take, playable. With it, each word that carries timings
+   * gets a button that plays just that word. A take the page refuses to play —
+   * a `blob:` URL under a Content-Security-Policy whose `media-src` does not
+   * allow one, most often — offers no such button, and the panel says the take
+   * cannot be played here.
+   */
+  audioUrl?: string;
+  /**
+   * Confidence above which a break note is shown, 0..1. **No default**: how
+   * confident an engine has to be before a pause is worth telling a learner
+   * about is a calibration, and the SDK has no calibrated answer. Without it no
+   * break note is shown at all.
+   */
+  breakThreshold?: number;
+  /** The same, for the monotone note read off `assessment.prosody`. */
+  monotoneThreshold?: number;
+  /**
+   * BCP 47 tag stamped as `lang` on the root: the INTERFACE language, the one
+   * this component's own sentences are written in. It is not `data.locale`,
+   * which is the language of the reading and is put on the words themselves.
+   */
+  locale?: string;
+  /** Per-instance token overrides, applied as inline CSS vars on the root. */
+  theme?: Partial<ThemeTokens>;
+  /** Overrides the SDK's chrome text for this panel. See {@link LkIntlProvider}. */
+  strings?: LkStringsOverride;
+  /**
+   * The host's AI ports, overriding `LkAiProvider`'s. With a
+   * `pronunciationCoaching` port the learner can ask for coaching on these
+   * marks — once per reading — which a model writes and the SDK checks: every
+   * word it coaches is one marked here, and every sound one the engine
+   * reported. See {@link LearnerAi}.
+   */
+  ai?: LearnerAi;
+  /**
+   * The mode the reading was given, for AI coaching alone: `exam` offers none,
+   * and an `exam` around the panel wins. The marks themselves show in any mode.
+   */
+  renderMode?: RenderMode;
+  /**
+   * What the paper lets a learner see. Coaching needs `feedback` and AI
+   * explanations; the paper around the panel holds as well.
+   */
+  delivery?: DeliveryPolicy | null;
+  /** Where `ai-coaching-shown` and `ai-help-refused` go. */
+  onInteraction?: (event: InteractionEvent) => void;
+}
+//#endregion
+//#region src/components/PronunciationFeedback/index.d.ts
+/**
+ * Public pronunciation-feedback panel: the core wrapped in
+ * `ActivityErrorBoundary` so a render failure (the dev throw for evidence
+ * `validateSpeechAssessment` refuses among them) degrades to an accessible
+ * fallback instead of crashing the host.
+ *
+ * **No `activityTitle`.** Its `data` is two fields of a read-aloud item and
+ * carries no title, so the production fallback is the unnamed one. Naming it
+ * would mean inventing a title for a panel that never had one.
+ */
+declare function PronunciationFeedback(props: PronunciationFeedbackProps): React.JSX.Element;
+//#endregion
+export { PronunciationFeedbackProps as n, PronunciationFeedback as t };
+//# sourceMappingURL=index-CzfRzks6.d.cts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index-CzfRzks6.d.cts","names":[],"sources":["../src/components/PronunciationFeedback/PronunciationFeedback.tsx","../src/components/PronunciationFeedback/index.tsx"],"mappings":";;;;;UAyDiB;;;;;;;EAOf,MAAM,KAAK,6CACT,QAAQ,KAAK;;;;;EAKf,YAAY;;;;;;;;EAQZ,QAAQ;;;;;;;;EAQR;;;;;;;EAOA;;EAEA;;;;;;EAMA;;EAEA,QAAQ,QAAQ;;EAEhB,UAAU;;;;;;;;EAQV,KAAK;;;;;EAKL,aAAa;;;;;EAKb,WAAW;;EAEX,iBAAiB,OAAO;;;;;;;;;;;;;;iBCxGV,sBAAsB,OAAO,6BAA6B,MAAM,IAAI"}

package/dist/index-D14xtpBS.d.cts

@@ -0,0 +1,24 @@
+import { t as ActivityProps } from "./types-BOQd93x3.cjs";
+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): React.JSX.Element;
+//#endregion
+export { MultipleChoiceProps as n, MultipleChoice as t };
+//# sourceMappingURL=index-D14xtpBS.d.cts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index-D14xtpBS.d.cts","names":[],"sources":["../src/components/MultipleChoice/MultipleChoice.tsx","../src/components/MultipleChoice/index.tsx"],"mappings":";;;UAyGiB,4BAA4B,cAAc;;;;;;;;EAQzD;;;;;;;;;iBCjGc,eAAe,OAAO,sBAAsB,MAAM,IAAI"}

package/dist/index-DHRPAPZf.d.ts

@@ -0,0 +1,291 @@
+import { t as LearnerAi } from "./LkAiProvider-QdEcIhoo.js";
+import { a as RenderMode, l as SequenceRecordingBinding, n as HtmlSanitizer, s as RenderableActivity, u as SequenceRecordingSlot, v as LkStringsOverride, x as VideoPreferences } from "./types-HIrgF_mS.js";
+import { ReactNode } from "react";
+import { ActivityResult, DeliveryPolicy, InteractionEvent, InteractionKind, ItemGroup, ItemOutcome, ItemScoringPolicy, LearnerResponse, MediaProgress, MediaTrack, ResolvedDeliveryPolicy, ResolvedItemScoringPolicy, SpeechAssessment, ThemeTokens } from "@intellectif/lk-core";
+//#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): React.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-DHRPAPZf.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index-DHRPAPZf.d.ts","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,wBAAwB,MAAM,IAAI"}

package/dist/index-DLV6cK26.d.cts

@@ -0,0 +1,16 @@
+import { t as ActivityProps } from "./types-BOQd93x3.cjs";
+import { DictationData } from "@intellectif/lk-core";
+//#region src/components/Dictation/Dictation.d.ts
+interface DictationProps extends ActivityProps<DictationData> {}
+//#endregion
+//#region src/components/Dictation/index.d.ts
+/**
+ * Public Dictation activity: the core wrapped in `ActivityErrorBoundary` so a
+ * render failure (including the dev schema-validation throw and the
+ * redacted-in-`practice` guard) degrades to an accessible fallback instead of
+ * crashing the host.
+ */
+declare function Dictation(props: DictationProps): React.JSX.Element;
+//#endregion
+export { DictationProps as n, Dictation as t };
+//# sourceMappingURL=index-DLV6cK26.d.cts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index-DLV6cK26.d.cts","names":[],"sources":["../src/components/Dictation/Dictation.tsx","../src/components/Dictation/index.tsx"],"mappings":";;;UA8CiB,uBAAuB,cAAc;;;;;;;;;iBChCtC,UAAU,OAAO,iBAAiB,MAAM,IAAI"}