@intellectif/lk-core 0.8.2 → 0.10.0

package/dist/{index-BvrA8nIV.d.ts → index-DSfETm4b.d.ts}

@@ -1,4 +1,4 @@
-import { A as ActivityData, c as ActivityMedia, t as ValidationResult, e as ActivityType, a as ActivityDataMap } from './activity-CPtJUBek.js';
+import { A as ActivityData, c as ActivityMedia, u as ValidationResult, e as ActivityType, a as ActivityDataMap } from './activity-B0zbvu18.js';
 import { z } from 'zod/v4';
 
 /** What a stimulus primarily is. Drives validation and layout, never scoring. */
@@ -273,6 +273,125 @@ declare const FillInTheBlanksDataSchema: z.ZodObject<{
     difficultyLevel: z.ZodOptional<z.ZodLiteral<2 | 1 | 3 | 4 | 5>>;
 }, z.core.$loose>;
 
+/**
+ * Zod schema for one selectable choice. Loose, like every other schema here:
+ * unknown keys are preserved so a consumer sidecar survives validation.
+ */
+declare const GapSelectChoiceSchema: z.ZodObject<{
+    id: z.ZodString;
+    text: z.ZodString;
+}, z.core.$loose>;
+/** Zod schema for a shared word bank. */
+declare const GapSelectBankSchema: z.ZodObject<{
+    id: z.ZodString;
+    choices: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        text: z.ZodString;
+    }, z.core.$loose>>;
+}, z.core.$loose>;
+/** Zod schema for one gap. The `choices` / `bankId` exclusivity is checked on the activity. */
+declare const GapSelectGapSchema: z.ZodObject<{
+    id: z.ZodString;
+    choices: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        text: z.ZodString;
+    }, z.core.$loose>>>;
+    bankId: z.ZodOptional<z.ZodString>;
+    correctChoiceId: z.ZodString;
+    feedback: z.ZodOptional<z.ZodString>;
+}, z.core.$loose>;
+/**
+ * Zod schema validating the full Gap Select data contract.
+ *
+ * Six semantic guards, none of them expressible in JSON Schema and all of them
+ * authoring errors that would otherwise reach a learner:
+ *
+ * 1. **Bank ids are unique** — two banks sharing an id makes which one a gap
+ *    draws from a matter of array order.
+ * 2. **Gap ids are unique** — the scorer looks a gap's selection up by id, so a
+ *    duplicate makes one gap unscoreable (the same defect the Multiple Choice
+ *    option-id guard exists for).
+ * 3. **Passage placeholders and gaps pair one to one**, each `{{id}}` appearing
+ *    exactly once — the Fill-in-the-Blanks bijection, for the same reason: a
+ *    gap with nowhere to render is a question the learner never sees, and a
+ *    placeholder with no gap renders as literal `{{id}}` text.
+ * 4. **Exactly one choice source per gap** — `choices` or `bankId`, never both
+ *    and never neither.
+ * 5. **A `bankId` names a bank that exists.**
+ * 6. **`correctChoiceId` is one of the choices the gap actually offers**, and
+ *    choice ids within a resolved set are unique. An answer key pointing at a
+ *    choice nobody can pick is an item that cannot be passed.
+ */
+declare const GapSelectDataSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"1.0">;
+    type: z.ZodLiteral<"gap-select">;
+    id: z.ZodString;
+    title: z.ZodString;
+    passage: z.ZodString;
+    passageHtml: z.ZodOptional<z.ZodString>;
+    gaps: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        choices: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            text: z.ZodString;
+        }, z.core.$loose>>>;
+        bankId: z.ZodOptional<z.ZodString>;
+        correctChoiceId: z.ZodString;
+        feedback: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>>;
+    banks: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        choices: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            text: z.ZodString;
+        }, z.core.$loose>>;
+    }, z.core.$loose>>>;
+    scoringStrategy: z.ZodEnum<{
+        "all-or-nothing": "all-or-nothing";
+        partial: "partial";
+    }>;
+    presentation: z.ZodOptional<z.ZodLiteral<"dropdown">>;
+    shuffleChoices: z.ZodOptional<z.ZodBoolean>;
+    media: z.ZodOptional<z.ZodObject<{
+        type: z.ZodEnum<{
+            image: "image";
+            audio: "audio";
+            video: "video";
+            embed: "embed";
+        }>;
+        url: z.ZodUnion<readonly [z.ZodURL, z.ZodString]>;
+        alt: z.ZodOptional<z.ZodString>;
+        captionsUrl: z.ZodOptional<z.ZodUnion<readonly [z.ZodURL, z.ZodString]>>;
+        playback: z.ZodOptional<z.ZodObject<{
+            controls: z.ZodOptional<z.ZodEnum<{
+                native: "native";
+                minimal: "minimal";
+            }>>;
+            maxPlays: z.ZodOptional<z.ZodNumber>;
+            seek: z.ZodOptional<z.ZodEnum<{
+                none: "none";
+                allow: "allow";
+            }>>;
+            rate: z.ZodOptional<z.ZodEnum<{
+                allow: "allow";
+                fixed: "fixed";
+            }>>;
+            nativeControlHints: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+                "hide-download": "hide-download";
+                "hide-rate": "hide-rate";
+            }>>>;
+        }, z.core.$strict>>;
+    }, z.core.$loose>>;
+    feedback: z.ZodOptional<z.ZodObject<{
+        correct: z.ZodOptional<z.ZodString>;
+        incorrect: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>>;
+    passThreshold: z.ZodOptional<z.ZodNumber>;
+    locale: z.ZodOptional<z.ZodString>;
+    learningObjectives: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    difficultyLevel: z.ZodOptional<z.ZodLiteral<2 | 1 | 3 | 4 | 5>>;
+}, z.core.$loose>;
+
 /**
  * Zod schema for a {@link Stimulus}. Loose: unknown keys preserved.
  *
@@ -542,6 +661,14 @@ declare const itemGroupJsonSchema: z.core.JSONSchema.JSONSchema;
  * `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: z.core.JSONSchema.JSONSchema;
 declare const multipleChoiceJsonSchema: z.core.JSONSchema.JSONSchema;
 /**
  * JSON Schema (Draft 7) representation of the Fill-in-the-Blanks activity data
@@ -759,11 +886,47 @@ declare const RedactedMediaSchema: z.ZodObject<{
  * Zod schema for a single Multiple Choice option. Loose: unknown keys are
  * preserved through validation (forward-compat / consumer sidecars — B7).
  */
+/**
+ * A picture or recording carried by one option.
+ *
+ * LOOSE, like `MediaSchema` and every other content schema: a consumer's own
+ * fields — an asset id, a CDN key — ride along and survive validation (B7).
+ * Making it strict to catch a typo would reject exactly the sidecars the SDK
+ * promises to preserve, and an invariant test guards that promise by counting
+ * the closed objects in the exported JSON Schema.
+ *
+ * The two things that must NOT be swallowed are named explicitly instead. The
+ * `type` enum refuses the kinds that cannot be an option, and a refinement
+ * refuses `playback`, which would otherwise sit there looking like an enforced
+ * budget while nothing read it.
+ *
+ * The URL goes through `MediaUrlSchema`, the same security-reviewed allow-list
+ * activity media uses — `javascript:`, `file:` and `ftp:` are stored-XSS
+ * vectors wherever the value lands in a `src`, and that list is not forked.
+ */
+declare const MultipleChoiceOptionMediaSchema: z.ZodObject<{
+    type: z.ZodEnum<{
+        image: "image";
+        audio: "audio";
+    }>;
+    url: z.ZodUnion<readonly [z.ZodURL, z.ZodString]>;
+    alt: z.ZodOptional<z.ZodString>;
+    captionsUrl: z.ZodOptional<z.ZodUnion<readonly [z.ZodURL, z.ZodString]>>;
+}, z.core.$loose>;
 declare const MultipleChoiceOptionSchema: z.ZodObject<{
     id: z.ZodString;
     text: z.ZodString;
     isCorrect: z.ZodBoolean;
     feedback: z.ZodOptional<z.ZodString>;
+    media: z.ZodOptional<z.ZodObject<{
+        type: z.ZodEnum<{
+            image: "image";
+            audio: "audio";
+        }>;
+        url: z.ZodUnion<readonly [z.ZodURL, z.ZodString]>;
+        alt: z.ZodOptional<z.ZodString>;
+        captionsUrl: z.ZodOptional<z.ZodUnion<readonly [z.ZodURL, z.ZodString]>>;
+    }, z.core.$loose>>;
 }, z.core.$loose>;
 /**
  * Zod schema validating the full Multiple Choice activity data contract.
@@ -796,6 +959,15 @@ declare const MultipleChoiceDataSchema: z.ZodObject<{
         text: z.ZodString;
         isCorrect: z.ZodBoolean;
         feedback: z.ZodOptional<z.ZodString>;
+        media: z.ZodOptional<z.ZodObject<{
+            type: z.ZodEnum<{
+                image: "image";
+                audio: "audio";
+            }>;
+            url: z.ZodUnion<readonly [z.ZodURL, z.ZodString]>;
+            alt: z.ZodOptional<z.ZodString>;
+            captionsUrl: z.ZodOptional<z.ZodUnion<readonly [z.ZodURL, z.ZodString]>>;
+        }, z.core.$loose>>;
     }, z.core.$loose>>;
     scoringStrategy: z.ZodEnum<{
         "all-or-nothing": "all-or-nothing";
@@ -843,9 +1015,36 @@ declare const MultipleChoiceDataSchema: z.ZodObject<{
 }, z.core.$loose>;
 
 /** A redacted Multiple Choice option: id and display text only — no `isCorrect`, no feedback. */
+declare const RedactedMultipleChoiceOptionMediaSchema: z.ZodObject<{
+    type: z.ZodEnum<{
+        image: "image";
+        audio: "audio";
+    }>;
+    url: z.ZodString;
+    alt: z.ZodOptional<z.ZodString>;
+    captionsUrl: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+/**
+ * A redacted Multiple Choice option: id, display text and its picture or
+ * recording — no `isCorrect`, no feedback.
+ *
+ * The media survives intact for the reason a gap-select choice does: it is the
+ * option the learner is being asked to pick, and an exam that stripped it would
+ * show a row of blanks. Nothing in it is an answer key — the key is `isCorrect`,
+ * which is gone.
+ */
 declare const RedactedMultipleChoiceOptionSchema: z.ZodObject<{
     id: z.ZodString;
     text: z.ZodString;
+    media: z.ZodOptional<z.ZodObject<{
+        type: z.ZodEnum<{
+            image: "image";
+            audio: "audio";
+        }>;
+        url: z.ZodString;
+        alt: z.ZodOptional<z.ZodString>;
+        captionsUrl: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
 }, z.core.$strict>;
 /**
  * Redacted Multiple Choice data: renderable (question, mode, options to pick
@@ -865,6 +1064,15 @@ declare const RedactedMultipleChoiceDataSchema: z.ZodObject<{
     options: z.ZodArray<z.ZodObject<{
         id: z.ZodString;
         text: z.ZodString;
+        media: z.ZodOptional<z.ZodObject<{
+            type: z.ZodEnum<{
+                image: "image";
+                audio: "audio";
+            }>;
+            url: z.ZodString;
+            alt: z.ZodOptional<z.ZodString>;
+            captionsUrl: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
     }, z.core.$strict>>;
     shuffle: z.ZodOptional<z.ZodBoolean>;
     /** Marker distinguishing a redacted projection from full activity data. */
@@ -965,6 +1173,106 @@ declare const RedactedFillInTheBlanksDataSchema: z.ZodObject<{
     learningObjectives: z.ZodOptional<z.ZodArray<z.ZodString>>;
     difficultyLevel: z.ZodOptional<z.ZodLiteral<2 | 1 | 3 | 4 | 5>>;
 }, z.core.$strict>;
+/** A redacted choice: exactly what it always was. Which one is correct was never stored here. */
+declare const RedactedGapSelectChoiceSchema: z.ZodObject<{
+    id: z.ZodString;
+    text: z.ZodString;
+}, z.core.$strict>;
+/** A redacted word bank: every choice survives, because the learner picks from them. */
+declare const RedactedGapSelectBankSchema: z.ZodObject<{
+    id: z.ZodString;
+    choices: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        text: z.ZodString;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+/** A redacted gap: its choice source survives; `correctChoiceId` and feedback do not. */
+declare const RedactedGapSelectGapSchema: z.ZodObject<{
+    id: z.ZodString;
+    choices: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        text: z.ZodString;
+    }, z.core.$strict>>>;
+    bankId: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+/**
+ * Redacted Gap Select data — the type where redaction **inverts** the
+ * Fill-in-the-Blanks rule, and the reason this is a separate schema rather than
+ * a variant of it.
+ *
+ * In Fill-in-the-Blanks the candidate answers ARE the key, so `acceptedAnswers`
+ * is stripped. Here the learner cannot answer at all without seeing every
+ * choice, so `choices` and `banks` must survive in full and `correctChoiceId`
+ * is the only field withheld. A policy that treated "the list of candidate
+ * answers" as answer-key for both types would ship an unanswerable exam.
+ *
+ * `scoringStrategy` stays answer-key for the same reason it does on the other
+ * two: knowing whether marking is partial tells a learner whether guessing at a
+ * gap is free.
+ */
+declare const RedactedGapSelectDataSchema: z.ZodObject<{
+    type: z.ZodLiteral<"gap-select">;
+    passage: z.ZodString;
+    passageHtml: z.ZodOptional<z.ZodString>;
+    gaps: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        choices: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            text: z.ZodString;
+        }, z.core.$strict>>>;
+        bankId: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    banks: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        choices: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            text: z.ZodString;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>>;
+    presentation: z.ZodOptional<z.ZodLiteral<"dropdown">>;
+    shuffleChoices: z.ZodOptional<z.ZodBoolean>;
+    /** Marker distinguishing a redacted projection from full activity data. */
+    redacted: z.ZodLiteral<true>;
+    /** Slot identity, carried through redaction so the client and the plan agree. */
+    slotKey: z.ZodOptional<z.ZodString>;
+    schemaVersion: z.ZodLiteral<"1.0">;
+    id: z.ZodString;
+    title: z.ZodString;
+    media: z.ZodOptional<z.ZodObject<{
+        type: z.ZodEnum<{
+            image: "image";
+            audio: "audio";
+            video: "video";
+            embed: "embed";
+        }>;
+        url: z.ZodUnion<readonly [z.ZodURL, z.ZodString]>;
+        alt: z.ZodOptional<z.ZodString>;
+        captionsUrl: z.ZodOptional<z.ZodUnion<readonly [z.ZodURL, z.ZodString]>>;
+        playback: z.ZodOptional<z.ZodObject<{
+            controls: z.ZodOptional<z.ZodEnum<{
+                native: "native";
+                minimal: "minimal";
+            }>>;
+            maxPlays: z.ZodOptional<z.ZodNumber>;
+            seek: z.ZodOptional<z.ZodEnum<{
+                none: "none";
+                allow: "allow";
+            }>>;
+            rate: z.ZodOptional<z.ZodEnum<{
+                allow: "allow";
+                fixed: "fixed";
+            }>>;
+            nativeControlHints: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+                "hide-download": "hide-download";
+                "hide-rate": "hide-rate";
+            }>>>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    passThreshold: z.ZodOptional<z.ZodNumber>;
+    locale: z.ZodOptional<z.ZodString>;
+    learningObjectives: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    difficultyLevel: z.ZodOptional<z.ZodLiteral<2 | 1 | 3 | 4 | 5>>;
+}, z.core.$strict>;
 /**
  * Redacted Written Response data: the prompt, word bounds and rubric are
  * learner-visible (a rubric tells the learner what they are graded on);
@@ -1043,6 +1351,8 @@ declare const RedactedWrittenResponseDataSchema: z.ZodObject<{
  * a renderer that must never see an answer key.
  */
 type RedactedMultipleChoiceOption = z.infer<typeof RedactedMultipleChoiceOptionSchema>;
+/** An option's picture or recording, unchanged by redaction — it is what the learner picks. */
+type RedactedMultipleChoiceOptionMedia = z.infer<typeof RedactedMultipleChoiceOptionMediaSchema>;
 /** A Multiple Choice item with the answer key, feedback and strategy removed. */
 type RedactedMultipleChoiceData = z.infer<typeof RedactedMultipleChoiceDataSchema>;
 /** A blank with its accepted answers and matching rules removed; the hint survives. */
@@ -1051,6 +1361,14 @@ type RedactedBlankConfig = z.infer<typeof RedactedBlankConfigSchema>;
 type RedactedFillInTheBlanksData = z.infer<typeof RedactedFillInTheBlanksDataSchema>;
 /** A Written Response item; the rubric survives, because it tells the learner what is assessed. */
 type RedactedWrittenResponseData = z.infer<typeof RedactedWrittenResponseDataSchema>;
+/** A selectable choice, unchanged by redaction. */
+type RedactedGapSelectChoice = z.infer<typeof RedactedGapSelectChoiceSchema>;
+/** A word bank, unchanged by redaction — the learner picks from it. */
+type RedactedGapSelectBank = z.infer<typeof RedactedGapSelectBankSchema>;
+/** A gap with its `correctChoiceId` removed; every choice it offers survives. */
+type RedactedGapSelectGap = z.infer<typeof RedactedGapSelectGapSchema>;
+/** A Gap Select item the learner can still answer: choices intact, answer key gone. */
+type RedactedGapSelectData = z.infer<typeof RedactedGapSelectDataSchema>;
 /**
  * Discriminated union of every built-in redacted activity. Narrow it on
  * `type`, exactly as you would {@link ActivityData}:
@@ -1063,7 +1381,7 @@ type RedactedWrittenResponseData = z.infer<typeof RedactedWrittenResponseDataSch
  * }
  * ```
  */
-type RedactedActivity = RedactedMultipleChoiceData | RedactedFillInTheBlanksData | RedactedWrittenResponseData;
+type RedactedActivity = RedactedMultipleChoiceData | RedactedFillInTheBlanksData | RedactedWrittenResponseData | RedactedGapSelectData;
 
 /** Zod schema for a single rubric criterion. Loose: unknown keys preserved. */
 declare const WrittenResponseRubricCriterionSchema: z.ZodObject<{
@@ -1160,4 +1478,4 @@ declare const WrittenResponseDataSchema: z.ZodObject<{
  */
 declare function validateActivity<T extends ActivityType>(type: T, data: unknown): ValidationResult<ActivityDataMap[T]>;
 
-export { WrittenResponseRubricSchema as A, BlankConfigSchema as B, fillInTheBlanksJsonSchema as C, itemGroupJsonSchema as D, jsonSchemaFor as E, FeedbackSchema as F, multipleChoiceJsonSchema as G, stimulusJsonSchema as H, type ItemGroup as I, validateActivity as J, validateItemGroup as K, writtenResponseJsonSchema as L, MediaPlaybackSchema as M, NativeControlHintSchema as N, type RedactedActivity as R, type SequenceEntry as S, TextMatchPolicySchema as T, WrittenResponseDataSchema as W, FillInTheBlanksDataSchema as a, ItemGroupSchema as b, MediaSchema as c, MediaUrlSchema as d, MultipleChoiceDataSchema as e, MultipleChoiceOptionSchema as f, type RedactedBlankConfig as g, RedactedBlankConfigSchema as h, type RedactedFillInTheBlanksData as i, RedactedFillInTheBlanksDataSchema as j, RedactedItemGroupSchema as k, RedactedMediaSchema as l, type RedactedMultipleChoiceData as m, RedactedMultipleChoiceDataSchema as n, type RedactedMultipleChoiceOption as o, RedactedMultipleChoiceOptionSchema as p, type RedactedStimulus as q, RedactedStimulusSchema as r, type RedactedWrittenResponseData as s, RedactedWrittenResponseDataSchema as t, type SequenceSlot as u, type SequenceSlotGroup as v, type Stimulus as w, type StimulusKind as x, StimulusSchema as y, WrittenResponseRubricCriterionSchema as z };
+export { itemGroupJsonSchema as $, type RedactedMultipleChoiceOption as A, BlankConfigSchema as B, type RedactedMultipleChoiceOptionMedia as C, RedactedMultipleChoiceOptionMediaSchema as D, RedactedMultipleChoiceOptionSchema as E, FeedbackSchema as F, GapSelectBankSchema as G, type RedactedStimulus as H, type ItemGroup as I, RedactedStimulusSchema as J, type RedactedWrittenResponseData as K, RedactedWrittenResponseDataSchema as L, MediaPlaybackSchema as M, NativeControlHintSchema as N, type SequenceSlot as O, type SequenceSlotGroup as P, type Stimulus as Q, type RedactedActivity as R, type SequenceEntry as S, type StimulusKind as T, StimulusSchema as U, TextMatchPolicySchema as V, WrittenResponseDataSchema as W, WrittenResponseRubricCriterionSchema as X, WrittenResponseRubricSchema as Y, fillInTheBlanksJsonSchema as Z, gapSelectJsonSchema as _, FillInTheBlanksDataSchema as a, jsonSchemaFor as a0, multipleChoiceJsonSchema as a1, stimulusJsonSchema as a2, validateActivity as a3, validateItemGroup as a4, writtenResponseJsonSchema as a5, GapSelectChoiceSchema as b, GapSelectDataSchema as c, GapSelectGapSchema as d, ItemGroupSchema as e, MediaSchema as f, MediaUrlSchema as g, MultipleChoiceDataSchema as h, MultipleChoiceOptionMediaSchema as i, MultipleChoiceOptionSchema as j, type RedactedBlankConfig as k, RedactedBlankConfigSchema as l, type RedactedFillInTheBlanksData as m, RedactedFillInTheBlanksDataSchema as n, type RedactedGapSelectBank as o, RedactedGapSelectBankSchema as p, type RedactedGapSelectChoice as q, RedactedGapSelectChoiceSchema as r, type RedactedGapSelectData as s, RedactedGapSelectDataSchema as t, type RedactedGapSelectGap as u, RedactedGapSelectGapSchema as v, RedactedItemGroupSchema as w, RedactedMediaSchema as x, type RedactedMultipleChoiceData as y, RedactedMultipleChoiceDataSchema as z };