@intellectif/lk-core 0.22.0 → 1.0.0

package/dist/index-BlOLlwOi.d.cts

@@ -0,0 +1,548 @@
+import { a as ActivityData, d as ActivityMedia, aq as ValidationResult, f as ActivityType, b as ActivityDataMap, ab as MultipleChoiceOptionMedia } from './activity-DgpBJeBc.cjs';
+
+/** What a stimulus primarily is. Drives validation and layout, never scoring. */
+type StimulusKind = 'text' | 'audio' | 'video' | 'image' | 'mixed';
+/**
+ * Shared material that several items refer to: a reading passage, a
+ * recording, a chart. Modelled as CONTENT — it lives inside the item group
+ * that carries it — so it works in a lesson quiz, a sequence and an exam
+ * section alike, and needs no blueprint to exist.
+ *
+ * Learner-visible by definition: the point of a stimulus is that the learner
+ * reads or hears it. The one exception is `transcript`, an author asset that
+ * `redactItemGroup` removes.
+ */
+interface Stimulus {
+    id: string;
+    kind: StimulusKind;
+    /** Optional heading (a passage title). */
+    title?: string;
+    /**
+     * Plain-text body: the passage itself, or short instructions above media.
+     * Required for `text` and `mixed`.
+     */
+    body?: string;
+    /**
+     * Optional sanitised rich-HTML sidecar of `body`. Requires `body`, which is
+     * the accessible fallback rendered when no sanitiser is supplied.
+     */
+    bodyHtml?: string;
+    /** The recording, video or image. Required for `audio`, `video`, `image` and `mixed`. */
+    media?: ActivityMedia;
+    /**
+     * Author-only transcript of `media` — for item generation and grading,
+     * never shown to the learner. Removed by `redactItemGroup`.
+     */
+    transcript?: string;
+    /** BCP 47 language tag of the material, when it differs from the items'. */
+    locale?: string;
+    /** Source credit, shown to the learner after the material. */
+    attribution?: string;
+}
+/**
+ * A quiz inside an interactive video: one moment of the video, and the
+ * questions shown there. The video pauses when playback reaches `at`, and the
+ * questions are shown one at a time, in `itemIds` order.
+ */
+interface TimelineCue {
+    /** Unique within the timeline. Names the quiz in events, the contents panel and drafts. */
+    id: string;
+    /**
+     * Seconds from the start of the video: finite and 0 or more. The SDK never
+     * reads the video, so it cannot check this against the duration: a quiz at
+     * or past the end opens when the video ends.
+     */
+    at: number;
+    /**
+     * `id`s of items in this group, in the order the quiz shows them. Non-empty.
+     * Every item of the group belongs to exactly one quiz.
+     */
+    itemIds: string[];
+    /** Optional heading shown above the questions. At most 120 characters. */
+    title?: string;
+    /**
+     * Every question must be answered (practice) or submitted (exam) before
+     * playback may pass `at`. Default false.
+     */
+    required?: boolean;
+}
+/** A titled section of the video. */
+interface TimelineChapter {
+    /** Seconds from the start: finite, 0 or more, strictly increasing across the list. */
+    at: number;
+    /** Non-empty after trimming; at most 120 characters. */
+    title: string;
+}
+/**
+ * The arrangement that turns an item group with a video stimulus into an
+ * interactive video: when each quiz opens, the video's chapters, and how far
+ * ahead a learner may seek.
+ *
+ * It lives on the container rather than inside `stimulus` because it describes
+ * how THESE questions are arranged over the material, not the material itself.
+ */
+interface MediaTimeline {
+    cues: TimelineCue[];
+    chapters?: TimelineChapter[];
+    /**
+     * `free` (default): seek anywhere. `no-skip-ahead`: rewind freely, never past
+     * the furthest point reached. Either way, playback never passes a `required`
+     * quiz that is not finished.
+     */
+    navigation?: 'free' | 'no-skip-ahead';
+}
+/**
+ * Where a learner stands in an interactive video, stored by the host so the
+ * video can resume. Kept apart from `AttemptState`, which holds answers by slot
+ * and drops fields it does not know. Read it back through
+ * `readMediaProgress`, never directly.
+ */
+interface MediaProgress {
+    progressVersion: '1.0';
+    /** Seconds: where playback last stood. */
+    at: number;
+    /**
+     * Seconds: the furthest point reached. Decides how far `no-skip-ahead` lets
+     * the learner seek, and how much of the transcript it shows.
+     */
+    furthest: number;
+}
+/**
+ * One stimulus serving several items. Two rules, both taken from observed
+ * failures: a group is SHUFFLE-ATOMIC (shuffling a sequence moves the group
+ * as one block — interleaving two passages' questions is the defect), and its
+ * stimulus is presented persistently alongside every item, never behind a
+ * toggle the learner must reopen per question.
+ *
+ * Generic over the item type so one shape describes a group of full activity
+ * data (authoring, server) and a group of `redact()` projections (client)
+ * without a cast at every boundary.
+ */
+interface ItemGroup<TItem = ActivityData> {
+    schemaVersion: '1.0';
+    type: 'item-group';
+    id: string;
+    title?: string;
+    /**
+     * Stable identity for this entry's slots, independent of where it sits in
+     * the array. See {@link SequenceSlot.slotId}: without one, inserting a
+     * question above this group re-maps every slot id beneath it, and stored
+     * grades quietly start naming different questions.
+     */
+    slotKey?: string;
+    stimulus: Stimulus;
+    /**
+     * The items, in authored order. Non-empty; ids unique within the group; no
+     * nested groups.
+     *
+     * An item may declare its own `slotKey`, for the same reason an entry can:
+     * it pins the item's identity within the group (`"reading.q1"` rather than
+     * `"reading.0"`), so inserting a question into a published group does not
+     * re-map the ones after it.
+     */
+    items: (TItem & {
+        slotKey?: string;
+    })[];
+    /**
+     * `none` (default) keeps authored order; `within-group` shuffles the items
+     * among themselves under the sequence seed. Either way the group stays one
+     * contiguous block.
+     */
+    shuffle?: 'none' | 'within-group';
+    /**
+     * Makes the group an interactive video: the stimulus must be a video, every
+     * item must be one of `INTERACTIVE_VIDEO_ITEM_TYPES`, and every item belongs
+     * to exactly one quiz. Items are then presented in quiz order, never
+     * shuffled. An older lk-core that does not know this field presents the same
+     * items as an ordinary video testlet, with the same slots and grades.
+     */
+    timeline?: MediaTimeline;
+}
+/**
+ * What a sequence is made of: loose activities and item groups, in authored
+ * order.
+ *
+ * A plain activity may carry `slotKey` here even though no activity SCHEMA
+ * declares one, because a slot key describes an item's PLACE in a paper, not
+ * its content — the same question keeps its own id in every paper it appears
+ * in. Putting it on the entry rather than on the activity is what lets it be
+ * authored without every activity type having to know about assessment
+ * assembly. See {@link SequenceSlot.slotId}.
+ */
+type SequenceEntry<TItem = ActivityData> = (TItem & {
+    slotKey?: string;
+}) | ItemGroup<TItem>;
+/** The group a presented slot belongs to. */
+interface SequenceSlotGroup {
+    id: string;
+    title?: string;
+    stimulus: Stimulus;
+    /** 0-based position of this slot within the group's PRESENTED order. */
+    position: number;
+    /** Number of slots in the group. */
+    size: number;
+    /** The group's timeline, when the group is an interactive video. */
+    timeline?: MediaTimeline;
+    /** The quiz this slot's item sits in, when the group is an interactive video. */
+    cue?: TimelineCue;
+}
+/** One presented position in a flattened sequence. */
+interface SequenceSlot<TItem = ActivityData> {
+    /**
+     * Identity of the slot within the sequence definition — unique, and stable
+     * under shuffling. Feed it to `composeAssessmentScore` as `slotId`.
+     *
+     * By default it is derived from the AUTHORED position (`"2"` for the third
+     * top-level entry; `"2.1"` for the second item of that entry when it is a
+     * group), so the same activity can appear in two entries and still be two
+     * slots.
+     *
+     * **A positional id is only valid against one version of the entries
+     * array.** Insert a question at the top of a published paper and every id
+     * below it shifts: rows stored as `"3"` now name what used to be entry 2,
+     * and a re-grade or a review render pairs each response with the wrong
+     * question — silently, because the ids still look valid. For any content
+     * whose slot ids you persist, give the entries an explicit `slotKey`; it is
+     * used verbatim here and survives insertion, deletion and re-ordering.
+     */
+    slotId: string;
+    /** 0-based PRESENTED position, after shuffling. */
+    index: number;
+    activity: TItem;
+    /** Present when the slot comes from an item group. */
+    group?: SequenceSlotGroup;
+}
+
+/**
+ * The learner-safe SHAPE of each built-in type.
+ *
+ * `redact()` returns `RedactedActivityData`, which proves a payload is
+ * learner-safe but is index-signature typed — it deliberately says nothing
+ * about what the payload still CONTAINS. That is right for the assertion and
+ * useless for anything that has to render or transport the result, so every
+ * integrator would end up re-declaring these interfaces by hand, and they would
+ * drift the moment a schema changed.
+ *
+ * Use them for the payload a server sends an exam client, and for the props of
+ * a renderer that must never see an answer key.
+ *
+ * Each is pinned to the strict schema `assertRedacted` checks against by a
+ * compile-time equality test, so the type and the validator cannot disagree.
+ * They are written out rather than inferred from those schemas so that the
+ * published types name no validation library.
+ */
+/** A caption or subtitle track, unchanged by redaction. */
+interface Track {
+    kind: 'captions' | 'subtitles';
+    src: string;
+    srclang: string;
+    label: string;
+    default?: boolean | undefined;
+}
+/** A recording's playback policy, unchanged by redaction. */
+interface Playback {
+    controls?: 'native' | 'minimal' | undefined;
+    maxPlays?: number | undefined;
+    seek?: 'allow' | 'none' | undefined;
+    rate?: 'allow' | 'fixed' | undefined;
+    nativeControlHints?: ('hide-download' | 'hide-rate')[] | undefined;
+}
+/** An item's or a stimulus's media, unchanged by redaction. */
+interface Media {
+    type: 'image' | 'audio' | 'video' | 'embed';
+    url: string;
+    alt?: string | undefined;
+    captionsUrl?: string | undefined;
+    tracks?: Track[] | undefined;
+    poster?: string | undefined;
+    playback?: Playback | undefined;
+}
+/** The author's switches for AI help, unchanged by redaction. */
+interface AiSwitches {
+    explanations?: boolean | undefined;
+    hints?: boolean | undefined;
+}
+/** What every redacted item carries, whatever its type. */
+interface RedactedItem {
+    redacted: true;
+    schemaVersion: '1.0';
+    id: string;
+    title: string;
+    slotKey?: string | undefined;
+    media?: Media | undefined;
+    passThreshold?: number | undefined;
+    learningObjectives?: string[] | undefined;
+    difficultyLevel?: 1 | 2 | 3 | 4 | 5 | undefined;
+    ai?: AiSwitches | undefined;
+}
+/** An option's picture or recording, unchanged by redaction — it is what the learner picks. */
+interface RedactedMultipleChoiceOptionMedia {
+    type: 'image' | 'audio';
+    url: string;
+    alt?: string | undefined;
+    captionsUrl?: string | undefined;
+}
+/** An option with `isCorrect` and its feedback removed. */
+interface RedactedMultipleChoiceOption {
+    id: string;
+    text: string;
+    media?: RedactedMultipleChoiceOptionMedia | undefined;
+}
+/** A Multiple Choice item with the answer key, feedback and strategy removed. */
+interface RedactedMultipleChoiceData extends RedactedItem {
+    type: 'multiple-choice';
+    question: string;
+    questionHtml?: string | undefined;
+    mode: 'single' | 'multi';
+    options: RedactedMultipleChoiceOption[];
+    shuffle?: boolean | undefined;
+    locale?: string | undefined;
+}
+/** A blank with its accepted answers and matching rules removed; the hint survives. */
+interface RedactedBlankConfig {
+    id: string;
+    hint?: string | undefined;
+}
+/** A Fill-in-the-Blanks item with every accepted answer removed. */
+interface RedactedFillInTheBlanksData extends RedactedItem {
+    type: 'fill-in-the-blanks';
+    passage: string;
+    passageHtml?: string | undefined;
+    blanks: RedactedBlankConfig[];
+    locale?: string | undefined;
+}
+/** A Written Response item; the rubric survives, because it tells the learner what is assessed. */
+interface RedactedWrittenResponseData extends RedactedItem {
+    type: 'written-response';
+    prompt: string;
+    promptHtml?: string | undefined;
+    minWords: number;
+    maxWords: number;
+    rubric?: {
+        criteria: {
+            name: string;
+            weight: number;
+            description?: string | undefined;
+        }[];
+        label?: string | undefined;
+    } | undefined;
+    languageTarget?: string | undefined;
+    locale?: string | undefined;
+}
+/** A selectable choice, unchanged by redaction. */
+interface RedactedGapSelectChoice {
+    id: string;
+    text: string;
+}
+/** A word bank, unchanged by redaction — the learner picks from it. */
+interface RedactedGapSelectBank {
+    id: string;
+    choices: RedactedGapSelectChoice[];
+}
+/** A gap with its `correctChoiceId` removed; every choice it offers survives. */
+interface RedactedGapSelectGap {
+    id: string;
+    choices?: RedactedGapSelectChoice[] | undefined;
+    bankId?: string | undefined;
+}
+/** A Gap Select item the learner can still answer: choices intact, answer key gone. */
+interface RedactedGapSelectData extends RedactedItem {
+    type: 'gap-select';
+    passage: string;
+    passageHtml?: string | undefined;
+    gaps: RedactedGapSelectGap[];
+    banks?: RedactedGapSelectBank[] | undefined;
+    presentation?: 'dropdown' | undefined;
+    shuffleChoices?: boolean | undefined;
+    locale?: string | undefined;
+}
+/** The slower recording of a dictation, unchanged by redaction. */
+interface RedactedDictationSlowMedia {
+    type: 'audio';
+    url: string;
+    alt?: string | undefined;
+}
+/** A Dictation item with its transcript, accepted alternatives and tolerances removed. */
+interface RedactedDictationData extends RedactedItem {
+    type: 'dictation';
+    slowMedia?: RedactedDictationSlowMedia | undefined;
+    hints?: {
+        mode: 'progressive-words';
+    } | undefined;
+    locale?: string | undefined;
+}
+/**
+ * A Read Aloud item, which keeps everything but the authored feedback: the text
+ * to read is what the learner is asked to read. The slow recording needs no
+ * redacted counterpart of its own — the content schema for it is already strict.
+ */
+interface RedactedReadAloudData extends RedactedItem {
+    type: 'read-aloud';
+    instructions?: string | undefined;
+    referenceText: string;
+    locale: string;
+    slowMedia?: RedactedDictationSlowMedia | undefined;
+    recording: {
+        maxSeconds: number;
+        minSeconds?: number | undefined;
+        maxTakes?: number | undefined;
+    };
+    scoring: {
+        dimensions: {
+            name: 'accuracy' | 'fluency' | 'completeness' | 'prosody';
+            weight: number;
+        }[];
+    };
+}
+/** A stimulus as a learner receives it: everything but the author-only `transcript`. */
+interface RedactedStimulus {
+    id: string;
+    kind: 'text' | 'image' | 'audio' | 'video' | 'mixed';
+    title?: string | undefined;
+    body?: string | undefined;
+    bodyHtml?: string | undefined;
+    media?: Media | undefined;
+    locale?: string | undefined;
+    attribution?: string | undefined;
+}
+/**
+ * Discriminated union of every built-in redacted activity. Narrow it on
+ * `type`, exactly as you would `ActivityData`:
+ *
+ * ```ts
+ * function render(item: RedactedActivity) {
+ *   if (item.type === 'multiple-choice') {
+ *     return item.options.map((option) => option.text); // no `isCorrect` to leak
+ *   }
+ * }
+ * ```
+ */
+type RedactedActivity = RedactedMultipleChoiceData | RedactedFillInTheBlanksData | RedactedWrittenResponseData | RedactedGapSelectData | RedactedDictationData | RedactedReadAloudData;
+
+/**
+ * Validates an item group in full: the container and stimulus against
+ * {@link ItemGroupSchema}, then every item against the schema registered for
+ * its `type`. Errors from items are reported at `items.<index>.…`.
+ *
+ * Unlike `validateActivity`, an item whose type is not registered is REPORTED
+ * (code `unknown_activity_type`) rather than thrown: a group is validated as
+ * a whole, and an author fixing a six-item group wants every problem listed,
+ * not the first one that happened to throw.
+ */
+declare function validateItemGroup(data: unknown): ValidationResult<ItemGroup>;
+
+/**
+ * JSON Schema (Draft 7) for a `Stimulus`. Structural contract only — the
+ * kind/media/body consistency guards are Zod-only.
+ */
+declare const stimulusJsonSchema: Record<string, unknown>;
+/**
+ * JSON Schema (Draft 7) for an `ItemGroup` CONTAINER. Items appear as objects
+ * with `type` and `id` only; each item's own contract is `jsonSchemaFor(type)`.
+ * For an AI generation pipeline, ask for the group and each item separately
+ * rather than a single nested schema — that keeps the per-type schema the
+ * registry's, not a copy.
+ */
+declare const itemGroupJsonSchema: Record<string, unknown>;
+/**
+ * JSON Schema (Draft 7) representation of the Multiple Choice activity data
+ * contract, generated natively by Zod 4. Draft 7 is mandated by Requirement
+ * 2.2 for the widest AI-prompt / OpenAPI tooling compatibility. The semantic
+ * `.refine()` guards are not representable in JSON Schema and are
+ * intentionally omitted — the export captures the *structural* contract only.
+ * Since v0.3 the source schemas are loose, so these no longer emit
+ * `additionalProperties: false` — the JSON Schema and `validateActivity` now
+ * agree on unknown-key handling.
+ */
+/**
+ * JSON Schema (Draft 7) representation of the Gap Select activity data
+ * contract. Structural contract only: the six semantic guards — the
+ * passage/gap bijection, id uniqueness, the one-choice-source rule, and an
+ * answer key that names a choice the gap offers — are Zod-only, as they are
+ * for the other types.
+ */
+declare const gapSelectJsonSchema: Record<string, unknown>;
+/**
+ * JSON Schema (Draft 7) representation of the Dictation activity data
+ * contract. Structural contract, plus the raw length caps JSON Schema can
+ * state in code points as zod counts them — `maxLength` 2000 on a transcript
+ * and an accepted transcript, 200 on a rule's `from` and `to`. The twelve
+ * semantic guards — a transcript that survives normalisation, the caps after
+ * equivalences are applied, distinct candidates, audio only, the
+ * slow-recording rules, no captions, no transcript in the title — are
+ * Zod-only, as they are for the other types.
+ */
+declare const dictationJsonSchema: Record<string, unknown>;
+/**
+ * JSON Schema (Draft 7) representation of the Read Aloud activity data
+ * contract. Structural contract, plus the raw cap JSON Schema can state in code
+ * points as zod counts them — `maxLength` 2000 on the reference text — and the
+ * canonical locale pattern. The ten semantic guards — the cap after
+ * normalisation, a text that survives it, the spaced-script rule, the
+ * model-recording rules, unique dimensions, a weight above 0, and the take
+ * bounds — are Zod-only, as they are for the other types.
+ */
+declare const readAloudJsonSchema: Record<string, unknown>;
+declare const multipleChoiceJsonSchema: Record<string, unknown>;
+/**
+ * JSON Schema (Draft 7) representation of the Fill-in-the-Blanks activity data
+ * contract, generated natively by Zod 4. Structural contract only (semantic
+ * `.refine()` guards are Zod-only and not representable in JSON Schema).
+ */
+declare const fillInTheBlanksJsonSchema: Record<string, unknown>;
+/**
+ * JSON Schema (Draft 7) representation of the Written Response activity data
+ * contract. Structural contract only.
+ */
+declare const writtenResponseJsonSchema: Record<string, unknown>;
+/**
+ * Derives the JSON Schema (Draft 7) for any REGISTERED activity type — the
+ * live, registry-backed replacement for the static per-type exports above,
+ * and the building block for AI generation pipelines (R6.1): pass the result
+ * as a structured-output schema so a model can only emit valid items.
+ *
+ * For a type you registered, it is the descriptor's `jsonSchema` when you gave
+ * one, or else what the schema produces through the Standard JSON Schema
+ * converter (`'~standard'.jsonSchema`) — a zod 4.6 schema has one. A fresh copy
+ * every call.
+ *
+ * @throws UnknownActivityTypeError when `type` has no registered descriptor.
+ * @throws Error when a registered type has neither a `jsonSchema` nor a schema
+ *   that can produce one.
+ */
+declare function jsonSchemaFor(type: string): Record<string, unknown>;
+
+/**
+ * Checks a piece of activity media — an item's `media`, a stimulus's, a
+ * dictation's `slowMedia` — on its own, the way `validateActivity` checks it
+ * inside an item: its kind, an address in the allowed schemes, a playback
+ * policy only on audio, captions and tracks only where they can play. For an
+ * editor's media picker, which holds the media before the item is whole.
+ *
+ * @returns `{ success: true, data }`, or `{ success: false, errors }` with the
+ *   same codes, paths and messages `validateActivity` reports.
+ */
+declare function validateMedia(value: unknown): ValidationResult<ActivityMedia>;
+/**
+ * Checks a multiple-choice option's `media` on its own: a picture or a
+ * recording, at an address in the allowed schemes, with no playback policy.
+ *
+ * @returns `{ success: true, data }`, or `{ success: false, errors }` with the
+ *   same codes, paths and messages `validateActivity` reports.
+ */
+declare function validateOptionMedia(value: unknown): ValidationResult<MultipleChoiceOptionMedia>;
+/**
+ * Validates raw activity data against the schema registered for the given
+ * activity type (built-in or consumer-registered via `registerActivityType`).
+ *
+ * Unknown keys are PRESERVED, not stripped: every built-in schema is loose,
+ * so consumer sidecar fields and forward-version fields survive validation
+ * verbatim in the returned `data`.
+ *
+ * @returns `{ success: true, data }` with the typed, validated data, or
+ *          `{ success: false, errors }` with one entry per failed constraint.
+ * @throws UnknownActivityTypeError when `type` has no registered descriptor.
+ */
+declare function validateActivity<T extends ActivityType>(type: T, data: unknown): ValidationResult<ActivityDataMap[T]>;
+
+export { readAloudJsonSchema as A, stimulusJsonSchema as B, validateActivity as C, validateItemGroup as D, validateMedia as E, validateOptionMedia as F, writtenResponseJsonSchema as G, type ItemGroup as I, type MediaProgress as M, type RedactedActivity as R, type SequenceEntry as S, type TimelineChapter as T, type MediaTimeline as a, type RedactedBlankConfig as b, type RedactedDictationData as c, type RedactedDictationSlowMedia as d, type RedactedFillInTheBlanksData as e, type RedactedGapSelectBank as f, type RedactedGapSelectChoice as g, type RedactedGapSelectData as h, type RedactedGapSelectGap as i, type RedactedMultipleChoiceData as j, type RedactedMultipleChoiceOption as k, type RedactedMultipleChoiceOptionMedia as l, type RedactedReadAloudData as m, type RedactedStimulus as n, type RedactedWrittenResponseData as o, type SequenceSlot as p, type SequenceSlotGroup as q, type Stimulus as r, type StimulusKind as s, type TimelineCue as t, dictationJsonSchema as u, fillInTheBlanksJsonSchema as v, gapSelectJsonSchema as w, itemGroupJsonSchema as x, jsonSchemaFor as y, multipleChoiceJsonSchema as z };