@intellectif/lk-react 23.1.0 → 23.1.2

package/dist/index-DbCCQ9cP.d.ts

@@ -0,0 +1,124 @@
+import { t as LearnerAi } from "./LkAiProvider-QdEcIhoo.js";
+import { a as RenderMode, i as MediaTransportStrings, n as HtmlSanitizer, o as Renderable, r as MediaBudgetBinding, v as LkStringsOverride } from "./types-HIrgF_mS.js";
+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-DbCCQ9cP.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index-DbCCQ9cP.d.ts","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-DeV5B2m5.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): React.JSX.Element;
+//#endregion
+export { MultipleChoiceProps as n, MultipleChoice as t };
+//# sourceMappingURL=index-DeV5B2m5.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index-DeV5B2m5.d.ts","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-TZCJVSge.d.ts

@@ -0,0 +1,28 @@
+import { t as ActivityProps } from "./types-HIrgF_mS.js";
+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-TZCJVSge.d.ts.map

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

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

package/dist/index-ZVvLHsd3.d.ts

@@ -0,0 +1,25 @@
+import { t as ActivityProps } from "./types-HIrgF_mS.js";
+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-ZVvLHsd3.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index-ZVvLHsd3.d.ts","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-eQwBgpSw.d.ts

@@ -0,0 +1,78 @@
+import { a as RenderMode, n as HtmlSanitizer, v as LkStringsOverride } from "./types-HIrgF_mS.js";
+import { t as ActivityRenderer } from "./index-Bsu8VciA.js";
+import { ReactNode } from "react";
+import { DraftNotComplete, ItemOutcome, LearnerResponse, ThemeTokens } from "@intellectif/lk-core";
+//#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-eQwBgpSw.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index-eQwBgpSw.d.ts","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.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