@intellectif/lk-react 23.1.0 → 23.1.2

package/dist/index-90CX504k.d.ts

@@ -0,0 +1,90 @@
+import { t as LearnerAi } from "./LkAiProvider-QdEcIhoo.js";
+import { a as RenderMode, v as LkStringsOverride } from "./types-HIrgF_mS.js";
+import "react";
+import { DeliveryPolicy, GradeRecord, InteractionEvent, ReadAloudData, SpeechAssessment, ThemeTokens } from "@intellectif/lk-core";
+//#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-90CX504k.d.ts.map

package/dist/index-90CX504k.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index-90CX504k.d.ts","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-B_SgnjsC.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): 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-B_SgnjsC.d.cts.map

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

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

package/dist/index-BavVW5z5.d.cts

@@ -0,0 +1,25 @@
+import { t as ActivityProps } from "./types-BOQd93x3.cjs";
+import { GapSelectData } from "@intellectif/lk-core";
+//#region src/components/GapSelect/GapSelect.d.ts
+interface GapSelectProps extends ActivityProps<GapSelectData> {
+  /**
+   * Seeds the per-gap choice shuffle when `data.shuffleChoices` is set. Pass
+   * the attempt id, exactly as on `<MultipleChoice>`: an order nobody can
+   * reproduce cannot be reconciled with the attempt a server recorded. Without
+   * one, a random per-mount seed is used — stable within the mount, and
+   * deliberately not reproducible.
+   */
+  shuffleSeed?: string;
+}
+//#endregion
+//#region src/components/GapSelect/index.d.ts
+/**
+ * Public Gap Select 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 GapSelect(props: GapSelectProps): React.JSX.Element;
+//#endregion
+export { GapSelectProps as n, GapSelect as t };
+//# sourceMappingURL=index-BavVW5z5.d.cts.map

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

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

package/dist/index-BhHv6Fiu.d.cts

@@ -0,0 +1,28 @@
+import { t as ActivityProps } from "./types-BOQd93x3.cjs";
+import { FillInTheBlanksData } from "@intellectif/lk-core";
+//#region src/components/FillInTheBlanks/FillInTheBlanks.d.ts
+interface FillInTheBlanksProps extends ActivityProps<FillInTheBlanksData> {
+  /**
+   * After submission, replace each incorrectly-answered blank with its first
+   * accepted answer, styled distinctly. Component-specific prop: it
+   * is presentation, not activity data, and is outside the fixed Req-3.1 set.
+   *
+   * Ignored in `exam` mode — revealing the key is precisely what an exam must
+   * not do, and on a `redact()` projection there is no key to reveal. In
+   * `review` mode it applies only to blanks the supplied `outcome` marks
+   * incorrect, and only when the caller passed data that still carries the key
+   * (e.g. `redact(data, { reveal: 'after-submit' })`).
+   */
+  showCorrectAnswers?: boolean;
+}
+//#endregion
+//#region src/components/FillInTheBlanks/index.d.ts
+/**
+ * Public Fill-in-the-Blanks activity: the core 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 FillInTheBlanks(props: FillInTheBlanksProps): React.JSX.Element;
+//#endregion
+export { FillInTheBlanksProps as n, FillInTheBlanks as t };
+//# sourceMappingURL=index-BhHv6Fiu.d.cts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index-BhHv6Fiu.d.cts","names":[],"sources":["../src/components/FillInTheBlanks/FillInTheBlanks.tsx","../src/components/FillInTheBlanks/index.tsx"],"mappings":";;;UAoCiB,6BAA6B,cAAc;;;;;;;;;;;;EAY1D;;;;;;;;;iBChCc,gBAAgB,OAAO,uBAAuB,MAAM,IAAI"}