@intellectif/lk-react 23.1.0 → 23.1.2

package/dist/ai/useAiHelp.d.ts

@@ -1,96 +1,94 @@
-import { AiCoaching, ReadAloudData, SpeechAssessment, GradeRecord, InteractionEvent, DeliveryPolicy, AiTextResult, LearnerResponse, ItemOutcome, AiWritingFeedback } from '@intellectif/lk-core';
-import { e as RenderMode, g as RenderableActivity } from '../types-C4IsUQsK.js';
-import { LearnerAi } from './LkAiProvider.js';
-import '../machine-CuwKqWXC.js';
-import 'react';
-
+import { t as LearnerAi } from "../LkAiProvider-QdEcIhoo.js";
+import { a as RenderMode, s as RenderableActivity } from "../types-HIrgF_mS.js";
+import { AiCoaching, AiTextResult, AiWritingFeedback, DeliveryPolicy, GradeRecord, InteractionEvent, ItemOutcome, LearnerResponse, ReadAloudData, SpeechAssessment } from "@intellectif/lk-core";
+//#region src/ai/useAiHelp.d.ts
 /**
  * The question AI help is being asked about, as the SDK's own components know
  * it. A host drawing its own question passes what it has; everything optional
  * defaults to what the components pass.
  */
-interface AiHelpSituation {
-    /** The question, as `data` is given to any activity component. */
-    data: RenderableActivity;
-    /** The learner's answer as it stands: submitted, restored, or being written. */
-    response: LearnerResponse;
-    /** Whether the learner has committed that answer. */
-    submitted: boolean;
-    /**
-     * Pass on the `renderMode` your question was given. Left out, the paper
-     * around the question answers for it — a question inside `<ActivitySequence>`
-     * or `<InteractiveVideo>` knows its mode — and `practice` only where there is
-     * no paper at all. An `exam` around the question wins over anything passed
-     * here.
-     */
-    renderMode?: RenderMode;
-    /**
-     * The AI ports to use, overriding {@link LkAiProvider}'s for this question.
-     * A question inside `<ActivitySequence>` or `<InteractiveVideo>` is handed
-     * the ports in force as `ai` — pass that straight in.
-     */
-    ai?: LearnerAi;
-    /** The interface language: the default language for what a model writes. */
-    locale?: string;
-    /** Where `ai-hint-shown` and `ai-explanation-shown` go. */
-    onInteraction?: (event: InteractionEvent) => void;
-    /**
-     * The delivery policy your question was handed. The paper around the
-     * question holds as well — a set that switched AI hints off keeps them off
-     * here, whatever is passed — so leaving it out never turns anything on.
-     */
-    delivery?: DeliveryPolicy | null;
+export interface AiHelpSituation {
+  /** The question, as `data` is given to any activity component. */
+  data: RenderableActivity;
+  /** The learner's answer as it stands: submitted, restored, or being written. */
+  response: LearnerResponse;
+  /** Whether the learner has committed that answer. */
+  submitted: boolean;
+  /**
+   * Pass on the `renderMode` your question was given. Left out, the paper
+   * around the question answers for it — a question inside `<ActivitySequence>`
+   * or `<InteractiveVideo>` knows its mode — and `practice` only where there is
+   * no paper at all. An `exam` around the question wins over anything passed
+   * here.
+   */
+  renderMode?: RenderMode;
+  /**
+   * The AI ports to use, overriding {@link LkAiProvider}'s for this question.
+   * A question inside `<ActivitySequence>` or `<InteractiveVideo>` is handed
+   * the ports in force as `ai` — pass that straight in.
+   */
+  ai?: LearnerAi;
+  /** The interface language: the default language for what a model writes. */
+  locale?: string;
+  /** Where `ai-hint-shown` and `ai-explanation-shown` go. */
+  onInteraction?: (event: InteractionEvent) => void;
+  /**
+   * The delivery policy your question was handed. The paper around the
+   * question holds as well — a set that switched AI hints off keeps them off
+   * here, whatever is passed — so leaving it out never turns anything on.
+   */
+  delivery?: DeliveryPolicy | null;
 }
-interface AiExplanationInput extends AiHelpSituation {
-    /** The grade of record, which `review` explains. */
-    outcome?: ItemOutcome;
+export interface AiExplanationInput extends AiHelpSituation {
+  /** The grade of record, which `review` explains. */
+  outcome?: ItemOutcome;
 }
-interface AiExplanationHelp {
-    /**
-     * Whether to offer the learner an explanation at all: a port is present, the
-     * answer is graded, the type is one the SDK explains, and the author left
-     * explanations on. False in `exam`, always.
-     */
-    offered: boolean;
-    status: 'idle' | 'loading' | 'shown' | 'unavailable';
-    /** What to show, once it has arrived and been checked. Its `text` is text, never HTML. */
-    explanation: AiTextResult | null;
-    /**
-     * Asks the port, when the learner presses something. Does nothing while a
-     * call is on its way, and nothing at all where `offered` is false — so an
-     * exam cannot reach a model through this hook, whatever ports are in scope.
-     *
-     * One identity for the life of the question, so it is safe in an effect's
-     * dependencies.
-     */
-    ask: () => void;
+export interface AiExplanationHelp {
+  /**
+   * Whether to offer the learner an explanation at all: a port is present, the
+   * answer is graded, the type is one the SDK explains, and the author left
+   * explanations on. False in `exam`, always.
+   */
+  offered: boolean;
+  status: 'idle' | 'loading' | 'shown' | 'unavailable';
+  /** What to show, once it has arrived and been checked. Its `text` is text, never HTML. */
+  explanation: AiTextResult | null;
+  /**
+   * Asks the port, when the learner presses something. Does nothing while a
+   * call is on its way, and nothing at all where `offered` is false — so an
+   * exam cannot reach a model through this hook, whatever ports are in scope.
+   *
+   * One identity for the life of the question, so it is safe in an effect's
+   * dependencies.
+   */
+  ask: () => void;
 }
-interface AiHintsInput extends AiHelpSituation {
-    /** A disabled question gives no hints, as it takes no answer. */
-    disabled?: boolean;
+export interface AiHintsInput extends AiHelpSituation {
+  /** A disabled question gives no hints, as it takes no answer. */
+  disabled?: boolean;
 }
-interface AiHintsHelp {
-    /**
-     * Whether the learner may ask for hints here at all: a port is present, the
-     * mode is `practice`, the answer is not in, the question is not disabled or
-     * redacted, the type takes hints and the author left them on. It stays true
-     * once `used` reaches `limit` — there are no more to give, but the question
-     * is still one that gives them.
-     */
-    offered: boolean;
-    status: 'idle' | 'loading' | 'unavailable';
-    /** Every hint shown for this question, in the order they were given. */
-    hints: readonly AiTextResult[];
-    /** The host's `maxHints`, as a whole number from 1 to 10 (3 by default). */
-    limit: number;
-    /** How many hints have been shown. A refused hint is not counted. */
-    used: number;
-    /**
-     * Asks for the next hint. Does nothing at the limit, while a call is on its
-     * way, or where `offered` is false. One identity for the life of the
-     * question.
-     */
-    ask: () => void;
+export interface AiHintsHelp {
+  /**
+   * Whether the learner may ask for hints here at all: a port is present, the
+   * mode is `practice`, the answer is not in, the question is not disabled or
+   * redacted, the type takes hints and the author left them on. It stays true
+   * once `used` reaches `limit` — there are no more to give, but the question
+   * is still one that gives them.
+   */
+  offered: boolean;
+  status: 'idle' | 'loading' | 'unavailable';
+  /** Every hint shown for this question, in the order they were given. */
+  hints: readonly AiTextResult[];
+  /** The host's `maxHints`, as a whole number from 1 to 10 (3 by default). */
+  limit: number;
+  /** How many hints have been shown. A refused hint is not counted. */
+  used: number;
+  /**
+   * Asks for the next hint. Does nothing at the limit, while a call is on its
+   * way, or where `offered` is false. One identity for the life of the
+   * question.
+   */
+  ask: () => void;
 }
 /**
  * "Explain my answer", without the SDK's own button and panel: the rules, the
@@ -124,7 +122,7 @@ interface AiHintsHelp {
  * still on its way is abandoned — a late explanation never lands beside an
  * answer it was not written for — as it is when the caller unmounts.
  */
-declare function useAiExplanation(input: AiExplanationInput): AiExplanationHelp;
+export declare function useAiExplanation(input: AiExplanationInput): AiExplanationHelp;
 /**
  * "Get a hint", without the SDK's own button and list: the rules, the call, the
  * checks and the record, for a question you draw yourself.
@@ -147,40 +145,40 @@ declare function useAiExplanation(input: AiExplanationInput): AiExplanationHelp;
  * Keep the hints on screen after submit — the learner can see what they were
  * given — while `offered` turns false. Another question starts with none.
  */
-declare function useAiHints(input: AiHintsInput): AiHintsHelp;
-interface AiWritingFeedbackInput extends AiHelpSituation {
-    /** A disabled question takes no feedback, as it takes no answer. */
-    disabled?: boolean;
+export declare function useAiHints(input: AiHintsInput): AiHintsHelp;
+export interface AiWritingFeedbackInput extends AiHelpSituation {
+  /** A disabled question takes no feedback, as it takes no answer. */
+  disabled?: boolean;
 }
-interface AiWritingFeedbackHelp {
-    /**
-     * Whether the learner may ask for feedback here at all: a port is present,
-     * the mode is `practice`, the answer is not in, the question is a written
-     * response that is not disabled or redacted, its author left explanations on,
-     * and the paper shows feedback and solutions and allows AI explanations. It
-     * stays true once `used` reaches `limit`.
-     */
-    offered: boolean;
-    status: 'idle' | 'loading' | 'unavailable';
-    /** Every piece of feedback shown for this question, oldest first. */
-    feedback: readonly AiWritingFeedback[];
-    /** The latest, or `null` before any. Its `text` is text, never HTML. */
-    latest: AiWritingFeedback | null;
-    /**
-     * Whether `latest` is about the draft as it stands. Once the learner revises,
-     * its corrections point at words that may no longer be there: say so.
-     */
-    current: boolean;
-    /** The host's `maxWritingFeedback`, as a whole number from 1 to 10 (3 by default). */
-    limit: number;
-    /** How many times feedback has been shown. A refused reply is not counted. */
-    used: number;
-    /**
-     * Asks for feedback on the draft as it stands. Does nothing at the limit,
-     * while a call is on its way, on an empty draft, or where `offered` is false.
-     * One identity for the life of the question.
-     */
-    ask: () => void;
+export interface AiWritingFeedbackHelp {
+  /**
+   * Whether the learner may ask for feedback here at all: a port is present,
+   * the mode is `practice`, the answer is not in, the question is a written
+   * response that is not disabled or redacted, its author left explanations on,
+   * and the paper shows feedback and solutions and allows AI explanations. It
+   * stays true once `used` reaches `limit`.
+   */
+  offered: boolean;
+  status: 'idle' | 'loading' | 'unavailable';
+  /** Every piece of feedback shown for this question, oldest first. */
+  feedback: readonly AiWritingFeedback[];
+  /** The latest, or `null` before any. Its `text` is text, never HTML. */
+  latest: AiWritingFeedback | null;
+  /**
+   * Whether `latest` is about the draft as it stands. Once the learner revises,
+   * its corrections point at words that may no longer be there: say so.
+   */
+  current: boolean;
+  /** The host's `maxWritingFeedback`, as a whole number from 1 to 10 (3 by default). */
+  limit: number;
+  /** How many times feedback has been shown. A refused reply is not counted. */
+  used: number;
+  /**
+   * Asks for feedback on the draft as it stands. Does nothing at the limit,
+   * while a call is on its way, on an empty draft, or where `offered` is false.
+   * One identity for the life of the question.
+   */
+  ask: () => void;
 }
 /**
  * "Get feedback on my draft", without the SDK's own button and panel: the
@@ -202,63 +200,63 @@ interface AiWritingFeedbackHelp {
  * mistakes." And show `indicativeScore` as what it is — an indication, not a
  * grade.
  */
-declare function useAiWritingFeedback(input: AiWritingFeedbackInput): AiWritingFeedbackHelp;
-interface AiCoachingInput {
-    /**
-     * The read-aloud item, as `data` is given to `<ReadAloud>` — or as much of
-     * one as coaching reads: its id, title, text and language, and the author's
-     * `instructions` and `ai` settings where it has them.
-     */
-    data: Pick<ReadAloudData, 'id' | 'title' | 'referenceText' | 'locale'> & Partial<Pick<ReadAloudData, 'instructions' | 'ai'>>;
-    /**
-     * The speech engine's assessment of the take, as the learner is shown it.
-     * When given, it is the marks — each word's, with its sounds and what each
-     * was heard as — and the only ones: see `aiCoachingRequest` in lk-core.
-     */
-    assessment?: SpeechAssessment | null;
-    /**
-     * The grade of record. Its score is context for the model; without an
-     * assessment, its word details are the marks, and they carry no sounds.
-     */
-    grade?: GradeRecord | null;
-    /**
-     * Pass on the `renderMode` your reading was given. Coaching is never offered
-     * in `exam`, and an `exam` around the reading wins over anything passed here.
-     */
-    renderMode?: RenderMode;
-    /** The AI ports to use, overriding {@link LkAiProvider}'s for this reading. */
-    ai?: LearnerAi;
-    /** The interface language: the default language for what a model writes. */
-    locale?: string;
-    /** Where `ai-coaching-shown` and `ai-help-refused` go. */
-    onInteraction?: (event: InteractionEvent) => void;
-    /**
-     * The delivery policy your reading was handed. Coaching needs feedback shown
-     * and AI explanations allowed; the paper around the reading holds as well.
-     */
-    delivery?: DeliveryPolicy | null;
+export declare function useAiWritingFeedback(input: AiWritingFeedbackInput): AiWritingFeedbackHelp;
+export interface AiCoachingInput {
+  /**
+   * The read-aloud item, as `data` is given to `<ReadAloud>` — or as much of
+   * one as coaching reads: its id, title, text and language, and the author's
+   * `instructions` and `ai` settings where it has them.
+   */
+  data: Pick<ReadAloudData, 'id' | 'title' | 'referenceText' | 'locale'> & Partial<Pick<ReadAloudData, 'instructions' | 'ai'>>;
+  /**
+   * The speech engine's assessment of the take, as the learner is shown it.
+   * When given, it is the marks — each word's, with its sounds and what each
+   * was heard as — and the only ones: see `aiCoachingRequest` in lk-core.
+   */
+  assessment?: SpeechAssessment | null;
+  /**
+   * The grade of record. Its score is context for the model; without an
+   * assessment, its word details are the marks, and they carry no sounds.
+   */
+  grade?: GradeRecord | null;
+  /**
+   * Pass on the `renderMode` your reading was given. Coaching is never offered
+   * in `exam`, and an `exam` around the reading wins over anything passed here.
+   */
+  renderMode?: RenderMode;
+  /** The AI ports to use, overriding {@link LkAiProvider}'s for this reading. */
+  ai?: LearnerAi;
+  /** The interface language: the default language for what a model writes. */
+  locale?: string;
+  /** Where `ai-coaching-shown` and `ai-help-refused` go. */
+  onInteraction?: (event: InteractionEvent) => void;
+  /**
+   * The delivery policy your reading was handed. Coaching needs feedback shown
+   * and AI explanations allowed; the paper around the reading holds as well.
+   */
+  delivery?: DeliveryPolicy | null;
 }
-interface AiCoachingHelp {
-    /**
-     * Whether to offer coaching at all: a `pronunciationCoaching` port is
-     * present, there are marks to coach, the mode is not `exam`, the item's
-     * author left explanations on, and the paper shows feedback and allows AI
-     * explanations.
-     */
-    offered: boolean;
-    status: 'idle' | 'loading' | 'shown' | 'unavailable';
-    /**
-     * What to show, once it has arrived and been checked: the coaching's text,
-     * and the words it works on in reading order, each with its tip and, where
-     * the engine reported one, the sound. All of it is text, never HTML.
-     */
-    coaching: AiCoaching | null;
-    /**
-     * Asks the port, when the learner presses something. Does nothing while a
-     * call is on its way, once coaching is shown — one per reading — or where
-     * `offered` is false. One identity for the life of the reading.
-     */
-    ask: () => void;
+export interface AiCoachingHelp {
+  /**
+   * Whether to offer coaching at all: a `pronunciationCoaching` port is
+   * present, there are marks to coach, the mode is not `exam`, the item's
+   * author left explanations on, and the paper shows feedback and allows AI
+   * explanations.
+   */
+  offered: boolean;
+  status: 'idle' | 'loading' | 'shown' | 'unavailable';
+  /**
+   * What to show, once it has arrived and been checked: the coaching's text,
+   * and the words it works on in reading order, each with its tip and, where
+   * the engine reported one, the sound. All of it is text, never HTML.
+   */
+  coaching: AiCoaching | null;
+  /**
+   * Asks the port, when the learner presses something. Does nothing while a
+   * call is on its way, once coaching is shown — one per reading — or where
+   * `offered` is false. One identity for the life of the reading.
+   */
+  ask: () => void;
 }
 /**
  * "Coach me on this reading", without the SDK's own button and panel: the
@@ -281,6 +279,6 @@ interface AiCoachingHelp {
  * Another reading — other marks, another text — drops the coaching and
  * abandons a call still on its way, as the caller unmounting does.
  */
-declare function useAiCoaching(input: AiCoachingInput): AiCoachingHelp;
-
-export { type AiCoachingHelp, type AiCoachingInput, type AiExplanationHelp, type AiExplanationInput, type AiHelpSituation, type AiHintsHelp, type AiHintsInput, type AiWritingFeedbackHelp, type AiWritingFeedbackInput, useAiCoaching, useAiExplanation, useAiHints, useAiWritingFeedback };
+export declare function useAiCoaching(input: AiCoachingInput): AiCoachingHelp;
+//#endregion
+//# sourceMappingURL=useAiHelp.d.ts.map

package/dist/ai/useAiHelp.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useAiHelp.d.ts","names":[],"sources":["../../src/ai/useAiHelp.ts"],"mappings":";;;;;;;;;iBA6CiB;;EAEf,MAAM;;EAEN,UAAU;;EAEV;;;;;;;;EAQA,aAAa;;;;;;EAMb,KAAK;;EAEL;;EAEA,iBAAiB,OAAO;;;;;;EAMxB,WAAW;;iBAGI,2BAA2B;;EAE1C,UAAU;;iBAGK;;;;;;EAMf;EACA;;EAEA,aAAa;;;;;;;;;EASb;;iBAGe,qBAAqB;;EAEpC;;iBAGe;;;;;;;;EAQf;EACA;;EAEA,gBAAgB;;EAEhB;;EAEA;;;;;;EAMA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBAwEc,iBAAiB,OAAO,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;wBA8H7C,WAAW,OAAO,eAAe;iBA2HhC,+BAA+B;;EAE9C;;iBAGe;;;;;;;;EAQf;EACA;;EAEA,mBAAmB;;EAEnB,QAAQ;;;;;EAKR;;EAEA;;EAEA;;;;;;EAMA;;;;;;;;;;;;;;;;;;;;;;wBAiCc,qBAAqB,OAAO,yBAAyB;iBA4IpD;;;;;;EAMf,MAAM,KAAK,8DACT,QAAQ,KAAK;;;;;;EAMf,aAAa;;;;;EAKb,QAAQ;;;;;EAKR,aAAa;;EAEb,KAAK;;EAEL;;EAEA,iBAAiB,OAAO;;;;;EAKxB,WAAW;;iBAGI;;;;;;;EAOf;EACA;;;;;;EAMA,UAAU;;;;;;EAMV;;;;;;;;;;;;;;;;;;;;;;;wBA4Bc,cAAc,OAAO,kBAAkB"}

package/dist/ai/useAiHelp.js

@@ -1,5 +1,4 @@
 'use client';
-export { useAiCoaching, useAiExplanation, useAiHints, useAiWritingFeedback } from '../chunk-MXNC5UNO.js';
-import '../chunk-ZPI6Q42R.js';
-//# sourceMappingURL=useAiHelp.js.map
-//# sourceMappingURL=useAiHelp.js.map
+"use client";
+import { i as useAiWritingFeedback, n as useAiExplanation, r as useAiHints, t as useAiCoaching } from "../useAiHelp-B-ccDL5Q.js";
+export { useAiCoaching, useAiExplanation, useAiHints, useAiWritingFeedback };

package/dist/components/ActivityPreview.cjs

@@ -1,30 +1,4 @@
 'use client';
-'use strict';
-
-var chunkV6BA44DS_cjs = require('../chunk-V6BA44DS.cjs');
-require('../chunk-MKXEM2C5.cjs');
-require('../chunk-YY4PFR3Z.cjs');
-require('../chunk-DS6HN3YR.cjs');
-require('../chunk-7ALBSPYR.cjs');
-require('../chunk-NAK55BYU.cjs');
-require('../chunk-KHKH5LCT.cjs');
-require('../chunk-TP5UMRAU.cjs');
-require('../chunk-LBEKRN6Y.cjs');
-require('../chunk-UDCQTOVU.cjs');
-require('../chunk-OD65OZIW.cjs');
-require('../chunk-2PNSVBLQ.cjs');
-require('../chunk-J3C72RPK.cjs');
-require('../chunk-LPUWXIPR.cjs');
-require('../chunk-NDBMKGQ5.cjs');
-require('../chunk-XOR4MPEN.cjs');
-require('../chunk-BIGGXHAW.cjs');
-require('../chunk-TUVENMXB.cjs');
-
-
-
-Object.defineProperty(exports, "ActivityPreview", {
-  enumerable: true,
-  get: function () { return chunkV6BA44DS_cjs.ActivityPreview; }
-});
-//# sourceMappingURL=ActivityPreview.cjs.map
-//# sourceMappingURL=ActivityPreview.cjs.map
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_ActivityPreview = require("../ActivityPreview-BKr34exz.cjs");
+exports.ActivityPreview = require_ActivityPreview.ActivityPreview;

package/dist/components/ActivityPreview.d.cts

@@ -1,81 +1,2 @@
-import * as react_jsx_runtime from 'react/jsx-runtime';
-import { LearnerResponse, ItemOutcome, DraftNotComplete, ThemeTokens } from '@intellectif/lk-core';
-import { ReactNode } from 'react';
-import { e as RenderMode, H as HtmlSanitizer, a as LkStringsOverride } from '../types-CJgZWtl4.cjs';
-import { ActivityRenderer } from './ActivitySequence.cjs';
-import '../ai/LkAiProvider.cjs';
-import '../machine-CuwKqWXC.cjs';
-import '../WrittenResponse-BpL9p2Hn.cjs';
-
-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_runtime.JSX.Element;
-
-export { ActivityPreview, type ActivityPreviewProps };
+import { n as ActivityPreviewProps, t as ActivityPreview } from "../index-CunUyeuN.cjs";
+export { ActivityPreview, type ActivityPreviewProps };

package/dist/components/ActivityPreview.d.ts

@@ -1,81 +1,2 @@
-import * as react_jsx_runtime from 'react/jsx-runtime';
-import { LearnerResponse, ItemOutcome, DraftNotComplete, ThemeTokens } from '@intellectif/lk-core';
-import { ReactNode } from 'react';
-import { e as RenderMode, H as HtmlSanitizer, a as LkStringsOverride } from '../types-C4IsUQsK.js';
-import { ActivityRenderer } from './ActivitySequence.js';
-import '../ai/LkAiProvider.js';
-import '../machine-CuwKqWXC.js';
-import '../WrittenResponse-B7A5gHMj.js';
-
-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_runtime.JSX.Element;
-
-export { ActivityPreview, type ActivityPreviewProps };
+import { n as ActivityPreviewProps, t as ActivityPreview } from "../index-eQwBgpSw.js";
+export { ActivityPreview, type ActivityPreviewProps };

package/dist/components/ActivityPreview.js

@@ -1,21 +1,3 @@
 'use client';
-export { ActivityPreview } from '../chunk-7NFY3M3W.js';
-import '../chunk-FKGMSOJF.js';
-import '../chunk-C7QZE5BI.js';
-import '../chunk-TCDJY3H6.js';
-import '../chunk-ABJJ3LII.js';
-import '../chunk-RBS5A2DF.js';
-import '../chunk-FDQR4GAZ.js';
-import '../chunk-DC4CQCK5.js';
-import '../chunk-XO5R73Y4.js';
-import '../chunk-MCO52PV5.js';
-import '../chunk-YORQQXGO.js';
-import '../chunk-ORT3KLGI.js';
-import '../chunk-7SB2MJA4.js';
-import '../chunk-MXNC5UNO.js';
-import '../chunk-TS7J6DTY.js';
-import '../chunk-6N43WDVG.js';
-import '../chunk-HNLRVRQR.js';
-import '../chunk-ZPI6Q42R.js';
-//# sourceMappingURL=ActivityPreview.js.map
-//# sourceMappingURL=ActivityPreview.js.map
+import { t as ActivityPreview } from "../ActivityPreview-1hhTkYuj.js";
+export { ActivityPreview };