@intellectif/lk-react 23.1.0 → 23.1.1

package/dist/i18n/LkIntlProvider.d.cts

@@ -1,38 +1,33 @@
-import { a as LkStringsOverride, L as LkStrings } from '../types-CJgZWtl4.cjs';
-export { D as DEFAULT_STRINGS, m as mergeStrings } from '../types-CJgZWtl4.cjs';
-import '@intellectif/lk-core';
-import '../ai/LkAiProvider.cjs';
-import 'react';
-import '../machine-CuwKqWXC.cjs';
-
+import { _ as LkStrings, g as DEFAULT_STRINGS, v as LkStringsOverride, y as mergeStrings } from "../types-BOQd93x3.cjs";
+//#region src/i18n/LkIntlProvider.d.ts
 /** Writing direction of the surrounding UI. `auto` defers to the locale. */
-type LkDirection = 'ltr' | 'rtl' | 'auto';
+export type LkDirection = 'ltr' | 'rtl' | 'auto';
 /** Resolves a BCP 47 tag to a writing direction. */
-declare function directionForLocale(locale: string | undefined): 'ltr' | 'rtl';
-interface LkIntlProviderProps {
-    /**
-     * Replaces the SDK's own chrome text. Anything omitted keeps its English
-     * default, so a partial translation degrades to mixed rather than to blank.
-     *
-     * A nested provider REPLACES the one above it rather than layering onto it —
-     * as a nested `ThemeProvider` restarts from `defaultTheme`. To layer, use a
-     * component's own `strings` prop, or compose with `mergeStrings`.
-     */
-    strings?: LkStringsOverride;
-    /**
-     * BCP 47 tag for the SDK's chrome — NOT for the authored content, which
-     * carries its own `locale`. Sets `lang` on the wrapper so a screen reader
-     * reads "Question 3 of 10" in the interface language rather than in the
-     * language of the passage beside it (WCAG 3.1.2).
-     */
-    locale?: string;
-    /**
-     * Writing direction. Defaults to `auto`, which derives it from `locale`.
-     * Set it explicitly when the surrounding application already manages `dir`
-     * and you do not want a second element declaring one.
-     */
-    direction?: LkDirection;
-    children: React.ReactNode;
+export declare function directionForLocale(locale: string | undefined): 'ltr' | 'rtl';
+export interface LkIntlProviderProps {
+  /**
+   * Replaces the SDK's own chrome text. Anything omitted keeps its English
+   * default, so a partial translation degrades to mixed rather than to blank.
+   *
+   * A nested provider REPLACES the one above it rather than layering onto it —
+   * as a nested `ThemeProvider` restarts from `defaultTheme`. To layer, use a
+   * component's own `strings` prop, or compose with `mergeStrings`.
+   */
+  strings?: LkStringsOverride;
+  /**
+   * BCP 47 tag for the SDK's chrome — NOT for the authored content, which
+   * carries its own `locale`. Sets `lang` on the wrapper so a screen reader
+   * reads "Question 3 of 10" in the interface language rather than in the
+   * language of the passage beside it (WCAG 3.1.2).
+   */
+  locale?: string;
+  /**
+   * Writing direction. Defaults to `auto`, which derives it from `locale`.
+   * Set it explicitly when the surrounding application already manages `dir`
+   * and you do not want a second element declaring one.
+   */
+  direction?: LkDirection;
+  children: React.ReactNode;
 }
 /**
  * Supplies the SDK's chrome text and writing direction to everything beneath.
@@ -59,7 +54,7 @@ interface LkIntlProviderProps {
  * teacher can see is untranslated. The mechanism is the deliverable; the words
  * belong to whoever speaks the language.
  */
-declare function LkIntlProvider({ strings, locale, direction, children, }: LkIntlProviderProps): React.JSX.Element;
+export declare function LkIntlProvider({ strings, locale, direction, children }: LkIntlProviderProps): React.JSX.Element;
 /**
  * The strings in force, with an optional per-component override layered on top.
  *
@@ -67,8 +62,9 @@ declare function LkIntlProvider({ strings, locale, direction, children, }: LkInt
  * standalone still needs its labels. Falling back to the English defaults is
  * what keeps `<MultipleChoice>` working with no setup at all.
  */
-declare function useLkStrings(override?: LkStringsOverride): LkStrings;
+export declare function useLkStrings(override?: LkStringsOverride): LkStrings;
 /** The direction in force. `ltr` with no provider. */
-declare function useLkDirection(): 'ltr' | 'rtl';
-
-export { type LkDirection, LkIntlProvider, type LkIntlProviderProps, LkStrings, LkStringsOverride, directionForLocale, useLkDirection, useLkStrings };
+export declare function useLkDirection(): 'ltr' | 'rtl';
+//#endregion
+export { DEFAULT_STRINGS, type LkStrings, type LkStringsOverride, mergeStrings };
+//# sourceMappingURL=LkIntlProvider.d.cts.map

package/dist/i18n/LkIntlProvider.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"LkIntlProvider.d.cts","names":[],"sources":["../../src/i18n/LkIntlProvider.tsx"],"mappings":";;;YAUY;;wBAqBI,mBAAmB;iBAQlB;;;;;;;;;EASf,UAAU;;;;;;;EAOV;;;;;;EAMA,YAAY;EACZ,UAAU,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;wBA4BF,iBACd,SACA,QACA,WACA,YACC,sBAAsB,MAAM,IAAI;;;;;;;;wBAgCnB,aAAa,WAAW,oBAAoB;;wBAO5C"}

package/dist/i18n/LkIntlProvider.d.ts

@@ -1,38 +1,33 @@
-import { a as LkStringsOverride, L as LkStrings } from '../types-C4IsUQsK.js';
-export { D as DEFAULT_STRINGS, m as mergeStrings } from '../types-C4IsUQsK.js';
-import '@intellectif/lk-core';
-import '../ai/LkAiProvider.js';
-import 'react';
-import '../machine-CuwKqWXC.js';
-
+import { _ as LkStrings, g as DEFAULT_STRINGS, v as LkStringsOverride, y as mergeStrings } from "../types-HIrgF_mS.js";
+//#region src/i18n/LkIntlProvider.d.ts
 /** Writing direction of the surrounding UI. `auto` defers to the locale. */
-type LkDirection = 'ltr' | 'rtl' | 'auto';
+export type LkDirection = 'ltr' | 'rtl' | 'auto';
 /** Resolves a BCP 47 tag to a writing direction. */
-declare function directionForLocale(locale: string | undefined): 'ltr' | 'rtl';
-interface LkIntlProviderProps {
-    /**
-     * Replaces the SDK's own chrome text. Anything omitted keeps its English
-     * default, so a partial translation degrades to mixed rather than to blank.
-     *
-     * A nested provider REPLACES the one above it rather than layering onto it —
-     * as a nested `ThemeProvider` restarts from `defaultTheme`. To layer, use a
-     * component's own `strings` prop, or compose with `mergeStrings`.
-     */
-    strings?: LkStringsOverride;
-    /**
-     * BCP 47 tag for the SDK's chrome — NOT for the authored content, which
-     * carries its own `locale`. Sets `lang` on the wrapper so a screen reader
-     * reads "Question 3 of 10" in the interface language rather than in the
-     * language of the passage beside it (WCAG 3.1.2).
-     */
-    locale?: string;
-    /**
-     * Writing direction. Defaults to `auto`, which derives it from `locale`.
-     * Set it explicitly when the surrounding application already manages `dir`
-     * and you do not want a second element declaring one.
-     */
-    direction?: LkDirection;
-    children: React.ReactNode;
+export declare function directionForLocale(locale: string | undefined): 'ltr' | 'rtl';
+export interface LkIntlProviderProps {
+  /**
+   * Replaces the SDK's own chrome text. Anything omitted keeps its English
+   * default, so a partial translation degrades to mixed rather than to blank.
+   *
+   * A nested provider REPLACES the one above it rather than layering onto it —
+   * as a nested `ThemeProvider` restarts from `defaultTheme`. To layer, use a
+   * component's own `strings` prop, or compose with `mergeStrings`.
+   */
+  strings?: LkStringsOverride;
+  /**
+   * BCP 47 tag for the SDK's chrome — NOT for the authored content, which
+   * carries its own `locale`. Sets `lang` on the wrapper so a screen reader
+   * reads "Question 3 of 10" in the interface language rather than in the
+   * language of the passage beside it (WCAG 3.1.2).
+   */
+  locale?: string;
+  /**
+   * Writing direction. Defaults to `auto`, which derives it from `locale`.
+   * Set it explicitly when the surrounding application already manages `dir`
+   * and you do not want a second element declaring one.
+   */
+  direction?: LkDirection;
+  children: React.ReactNode;
 }
 /**
  * Supplies the SDK's chrome text and writing direction to everything beneath.
@@ -59,7 +54,7 @@ interface LkIntlProviderProps {
  * teacher can see is untranslated. The mechanism is the deliverable; the words
  * belong to whoever speaks the language.
  */
-declare function LkIntlProvider({ strings, locale, direction, children, }: LkIntlProviderProps): React.JSX.Element;
+export declare function LkIntlProvider({ strings, locale, direction, children }: LkIntlProviderProps): React.JSX.Element;
 /**
  * The strings in force, with an optional per-component override layered on top.
  *
@@ -67,8 +62,9 @@ declare function LkIntlProvider({ strings, locale, direction, children, }: LkInt
  * standalone still needs its labels. Falling back to the English defaults is
  * what keeps `<MultipleChoice>` working with no setup at all.
  */
-declare function useLkStrings(override?: LkStringsOverride): LkStrings;
+export declare function useLkStrings(override?: LkStringsOverride): LkStrings;
 /** The direction in force. `ltr` with no provider. */
-declare function useLkDirection(): 'ltr' | 'rtl';
-
-export { type LkDirection, LkIntlProvider, type LkIntlProviderProps, LkStrings, LkStringsOverride, directionForLocale, useLkDirection, useLkStrings };
+export declare function useLkDirection(): 'ltr' | 'rtl';
+//#endregion
+export { DEFAULT_STRINGS, type LkStrings, type LkStringsOverride, mergeStrings };
+//# sourceMappingURL=LkIntlProvider.d.ts.map

package/dist/i18n/LkIntlProvider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"LkIntlProvider.d.ts","names":[],"sources":["../../src/i18n/LkIntlProvider.tsx"],"mappings":";;;YAUY;;wBAqBI,mBAAmB;iBAQlB;;;;;;;;;EASf,UAAU;;;;;;;EAOV;;;;;;EAMA,YAAY;EACZ,UAAU,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;wBA4BF,iBACd,SACA,QACA,WACA,YACC,sBAAsB,MAAM,IAAI;;;;;;;;wBAgCnB,aAAa,WAAW,oBAAoB;;wBAO5C"}

package/dist/i18n/LkIntlProvider.js

@@ -1,4 +1,4 @@
 'use client';
-export { DEFAULT_STRINGS, LkIntlProvider, directionForLocale, mergeStrings, useLkDirection, useLkStrings } from '../chunk-HNLRVRQR.js';
-//# sourceMappingURL=LkIntlProvider.js.map
-//# sourceMappingURL=LkIntlProvider.js.map
+"use client";
+import { a as DEFAULT_STRINGS, i as useLkStrings, n as directionForLocale, o as mergeStrings, r as useLkDirection, t as LkIntlProvider } from "../LkIntlProvider-D_FdYXjQ.js";
+export { DEFAULT_STRINGS, LkIntlProvider, directionForLocale, mergeStrings, useLkDirection, useLkStrings };

package/dist/index-2iDJohip.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): import("react/jsx-runtime").JSX.Element;
+//#endregion
+export { PronunciationFeedbackProps as n, PronunciationFeedback as t };
+//# sourceMappingURL=index-2iDJohip.d.cts.map

package/dist/index-2iDJohip.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index-2iDJohip.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,yDAA0B,IAAA"}

package/dist/index-BAqT5tXN.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): import("react/jsx-runtime").JSX.Element;
+//#endregion
+export { PronunciationFeedbackProps as n, PronunciationFeedback as t };
+//# sourceMappingURL=index-BAqT5tXN.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index-BAqT5tXN.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,yDAA0B,IAAA"}

package/dist/index-BRbEfXgE.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-DRMauOVH.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): import("react/jsx-runtime").JSX.Element;
+//#endregion
+export { ActivityPreviewProps as n, ActivityPreview as t };
+//# sourceMappingURL=index-BRbEfXgE.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index-BRbEfXgE.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,mDAAoB,IAAA"}

package/dist/index-BW7aA5eN.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): import("react/jsx-runtime").JSX.Element;
+//#endregion
+export { GapSelectProps as n, GapSelect as t };
+//# sourceMappingURL=index-BW7aA5eN.d.cts.map

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

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

package/dist/index-BeiVd-qe.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): import("react/jsx-runtime").JSX.Element;
+//#endregion
+export { WrittenResponseProps as n, WrittenResponseSubmission as r, WrittenResponse as t };
+//# sourceMappingURL=index-BeiVd-qe.d.ts.map

package/dist/index-BeiVd-qe.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index-BeiVd-qe.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,mDAAoB,IAAA"}