@intellectif/lk-core 1.6.0 → 1.8.0

package/dist/{ai-i3jwXnpX.d.cts → ai-Cnm0qE8v.d.ts}

@@ -1,4 +1,3 @@
-//#region src/scoring/text-match.d.ts
 /**
  * Configurable free-text answer matching (R3.3).
  *
@@ -63,8 +62,6 @@ declare function levenshteinDistance(a: string, b: string, max: number): number;
  * semantics: `trim` + locale-insensitive `toLowerCase` + strict equality.
  */
 declare function matchText(input: string, accepted: string | readonly string[], policy?: TextMatchPolicy): TextMatchResult;
-//#endregion
-//#region src/types/grading.d.ts
 /**
  * Lifecycle of a deferred grade. A grade exists only in the `graded` state;
  * every other state means "no grade, and here is why" — which is precisely the
@@ -243,8 +240,6 @@ interface GradeRecord {
   /** Where `routeGrade` sent this grade, and why, when it was routed. */
   routing?: GradeRouting;
 }
-//#endregion
-//#region src/types/xapi.d.ts
 /**
  * An xAPI Activity object — the thing a statement is about.
  * This SDK only builds Activity-type objects (xAPI 1.0.3 §4.1.4.1).
@@ -402,8 +397,6 @@ interface XAPIError {
   /** Human-readable error description. */
   message: string;
 }
-//#endregion
-//#region src/types/activity.d.ts
 /**
  * Maps each ActivityType string to its corresponding data shape.
  *
@@ -637,6 +630,13 @@ interface MultipleChoiceData {
   id: string;
   /** Human-readable title used in xAPI statements and error boundaries. */
   title: string;
+  /**
+   * Optional instructions shown to the learner, as plain text: the task, read
+   * before the question and never part of it ("Choose the correct option to
+   * complete the conversation."). Every AI request about the item carries them.
+   * Instructions a run of questions shares go in an item group's text stimulus.
+   */
+  instructions?: string;
   /** The question stem presented to the learner, as plain text. */
   question: string;
   /**
@@ -774,6 +774,14 @@ interface GapSelectData {
   id: string;
   /** Human-readable title used in xAPI statements and error boundaries. */
   title: string;
+  /**
+   * Optional instructions shown to the learner, as plain text: the task, read
+   * before the passage and never part of it ("Complete the sentence. Use ONE
+   * word."). Every AI request about the item carries them. A `{{id}}`
+   * placeholder here is refused: gaps live in the passage only. Instructions
+   * a run of questions shares go in an item group's text stimulus.
+   */
+  instructions?: string;
   /** Passage text containing `{{gap_id}}` placeholders. */
   passage: string;
   /**
@@ -831,6 +839,14 @@ interface FillInTheBlanksData {
   id: string;
   /** Human-readable title used in xAPI statements and error boundaries. */
   title: string;
+  /**
+   * Optional instructions shown to the learner, as plain text: the task, read
+   * before the passage and never part of it ("Complete the sentence. Use ONE
+   * word."). Every AI request about the item carries them. A `{{id}}`
+   * placeholder here is refused: blanks live in the passage only. Instructions
+   * a run of questions shares go in an item group's text stimulus.
+   */
+  instructions?: string;
   /** Passage text containing `{{blank_id}}` placeholders. */
   passage: string;
   /**
@@ -1538,8 +1554,6 @@ interface InteractionEvent {
   /** Additional event-specific data. */
   payload: Record<string, unknown>;
 }
-//#endregion
-//#region src/types/authoring.d.ts
 /**
  * Why a draft is not an activity yet.
  *
@@ -1603,6 +1617,60 @@ type ItemFindingSeverity = 'warning' | 'advice';
  */
 interface ItemFinding extends ValidationError {
   severity: ItemFindingSeverity;
+  /**
+   * The other places a finding about several items involves, by path from the
+   * same root as `path`: the item whose passage holds another's answer, the
+   * questions whose keys share a position. Absent when only `path` is involved.
+   */
+  related?: string[][];
+}
+/**
+ * One form of an exam, as `critiqueVersions` reads it: its sections in paper
+ * order, each a list of sequence entries. A host without sections passes one.
+ */
+interface VersionPaper {
+  sections: readonly {
+    key?: string;
+    title?: string;
+    entries: readonly unknown[];
+  }[];
+}
+/**
+ * One thing `critiqueVersions` found between two forms. `a` and `b` are where
+ * it is in each, by path from the paper's root:
+ * `['sections', '0', 'entries', '2', 'items', '1']`.
+ *
+ * - `invalid` — the two are not parallel: a different blueprint, type or
+ *   structure, so they do not score alike.
+ * - `warning` — they are parallel, but a re-sitting learner would meet
+ *   something again, or one form is longer or tests another objective.
+ * - `advice` — a picture both forms show, which a host may allow.
+ */
+interface VersionFinding extends ValidationError {
+  severity: 'invalid' | 'warning' | 'advice';
+  a?: string[];
+  b?: string[];
+}
+/** One slot of the first form, with the slot of the second paired with it, and how they were paired. */
+interface VersionSlot {
+  a: string[] | null;
+  b: string[] | null;
+  by: 'pairs' | 'slotKey' | 'position';
+}
+/** What `critiqueVersions` found. */
+interface VersionComparison {
+  findings: VersionFinding[];
+  /** Every slot of either form — entries, and the items of a group — paired or not. */
+  slots: VersionSlot[];
+  summary: {
+    /** Items in each form: loose activities and the items of groups. */
+    aItems: number;
+    bItems: number;
+    /** Items paired with one of the other form. */
+    paired: number;
+    /** Paired slots whose structure differs. */
+    structureMismatches: number;
+  };
 }
 /** What `createDraft` hands an activity type's `authoring.createDraft`. */
 interface DraftContext {
@@ -1614,8 +1682,6 @@ interface DraftContext {
    */
   newId: () => string;
 }
-//#endregion
-//#region src/types/item-group.d.ts
 /** What a stimulus primarily is. Drives validation and layout, never scoring. */
 type StimulusKind = 'text' | 'audio' | 'video' | 'image' | 'mixed';
 /**
@@ -1834,8 +1900,6 @@ interface SequenceSlot<TItem = ActivityData> {
   /** Present when the slot comes from an item group. */
   group?: SequenceSlotGroup;
 }
-//#endregion
-//#region src/types/ai.d.ts
 /**
  * What an author allows AI to do for one item. Absent, or a feature left out,
  * leaves the choice to the deployment. `false` switches a feature off for this
@@ -1903,6 +1967,11 @@ interface AiOptionFact {
 }
 interface AiMultipleChoiceFacts extends AiFactsBase {
   activityType: 'multiple-choice';
+  /**
+   * The item's instructions, when it has any: the task the learner reads
+   * before the question. They say what to do, and are never part of the text answered.
+   */
+  instructions?: string;
   question: string;
   mode: 'single' | 'multi';
   options: AiOptionFact[];
@@ -1925,6 +1994,11 @@ interface AiBlankFact {
 }
 interface AiFillInTheBlanksFacts extends AiFactsBase {
   activityType: 'fill-in-the-blanks';
+  /**
+   * The item's instructions, when it has any: the task the learner reads
+   * before the passage. They say what to do, and are never part of the text answered.
+   */
+  instructions?: string;
   /** The passage, each blank written as `[1]`, `[2]`… in passage order. */
   passage: string;
   blanks: AiBlankFact[];
@@ -1947,6 +2021,11 @@ interface AiGapFact {
 }
 interface AiGapSelectFacts extends AiFactsBase {
   activityType: 'gap-select';
+  /**
+   * The item's instructions, when it has any: the task the learner reads
+   * before the passage. They say what to do, and are never part of the text answered.
+   */
+  instructions?: string;
   /** The passage, each gap written as `[1]`, `[2]`… in passage order. */
   passage: string;
   gaps: AiGapFact[];
@@ -2647,6 +2726,245 @@ interface AiVideoDraft {
   /** What `critiqueItemGroupDraft` says of it. */
   findings: ItemFinding[];
 }
-//#endregion
-export { AiVerdict as $, MultipleChoiceData as $t, AiGapSelectFacts as A, XAPIStatement as An, ActivityType as At, AiHintRequest as B, GradingState as Bn, FillInTheBlanksLearnerResponse as Bt, AiDraftsCall as C, XAPIConfig as Cn, ItemFinding as Ct, AiFeature as D, XAPIObject as Dn, ActivityFeedback as Dt, AiExplanationRequest as E, XAPIError as En, ActivityDataMap as Et, AiGradingFacts as F, GradeRoutingReason as Fn, DictationEquivalence as Ft, AiProvenance as G, matchText as Gn, GapSelectLearnerResponse as Gt, AiMaterialFacts as H, TextMatchPolicy as Hn, GapSelectChoice as Ht, AiGradingJudgement as I, Grader as In, DictationLearnerResponse as It, AiRefusal as J, ItemOutcome as Jt, AiReadingFacts as K, InteractionEvent as Kt, AiGradingRequest as L, GraderConfiguration as Ln, DictationSlowMedia as Lt, AiGrade as M, CriterionScore as Mn, DeferredReason as Mt, AiGradedCriterion as N, GradeRecord as Nn, DeferredScoringPartial as Nt, AiFillInTheBlanksFacts as O, XAPIResult as On, ActivityMedia as Ot, AiGradingCriterionFact as P, GradeRouting as Pn, DictationData as Pt, AiTextResult as Q, MediaTrack as Qt, AiGradingRequestProblem as R, GraderKind as Rn, DictationTolerance as Rt, AiDrafts as S, XAPIActor as Sn, DraftValidationResult as St, AiDraftsRun as T, XAPIContextActivities as Tn, ActivityData as Tt, AiMultipleChoiceFacts as U, TextMatchResult as Un, GapSelectData as Ut, AiItemFacts as V, InlineCorrection as Vn, GapSelectBank as Vt, AiOptionFact as W, levenshteinDistance as Wn, GapSelectGap as Wt, AiSoundFact as X, LearnerResponseMap as Xt, AiRubricCriterionFact as Y, LearnerResponse as Yt, AiSupportedActivityType as Z, MediaPlaybackPolicy as Zt, AiDraftCaption as _, WrittenResponseData as _n, DraftComplete as _t, AiCoachingRequest as a, ReadAloudDimension as an, AiWritingFeedbackRequest as at, AiDraftSource as b, WrittenResponseRubricCriterion as bn, DraftNotComplete as bt, AiCriterionJudgement as c, ReadAloudSlowMedia as cn, MediaProgress as ct, AiCritiqueFinding as d, ScoringDetail as dn, SequenceSlot as dt, MultipleChoiceLearnerResponse as en, AiVideoDraft as et, AiCritiqueFindingResult as f, ScoringOutcome as fn, SequenceSlotGroup as ft, AiDictationFacts as g, ValidationResult as gn, TimelineCue as gt, AiCritiqueResult as h, ValidationError as hn, TimelineChapter as ht, AiCoaching as i, ReadAloudData as in, AiWritingFeedback as it, AiGeneratedDraft as j, XAPIVerbObject as jn, BlankConfig as jt, AiGapFact as k, XAPIScore as kn, ActivityResult as kt, AiCritique as l, RecordingBounds as ln, MediaTimeline as lt, AiCritiqueRequest as m, ScriptTurn as mn, StimulusKind as mt, AiActivityInput as n, MultipleChoiceOptionMedia as nn, AiWritingCorrection as nt, AiCoachingResult as o, ReadAloudDimensionWeight as on, AiWritingFeedbackResult as ot, AiCritiqueKind as p, ScoringResult as pn, Stimulus as pt, AiReadingWordFact as q, InteractionKind as qt, AiBlankFact as r, NativeControlHint as rn, AiWritingFacts as rt, AiCoachingWord as s, ReadAloudLearnerResponse as sn, ItemGroup as st, ActivityAiPermissions as t, MultipleChoiceOption as tn, AiWordFact as tt, AiCritiqueField as u, RecordingRef as un, SequenceEntry as ut, AiDraftProblem as v, WrittenResponseLearnerResponse as vn, DraftContext as vt, AiDraftsRequest as w, XAPIContext as wn, ItemFindingSeverity as wt, AiDraftType as x, WrittenResponseRubricLevel as xn, DraftSeverity as xt, AiDraftSettings as y, WrittenResponseRubric as yn, DraftIssue as yt, AiGroupInput as z, GraderUsage as zn, FillInTheBlanksData as zt };
-//# sourceMappingURL=ai-i3jwXnpX.d.cts.map
+/**
+ * How hard a variant is meant to be next to its exemplar: one step, inside the
+ * level, never another level. `same` is a parallel form. The SDK cannot
+ * measure difficulty: this is an instruction to the model, and item statistics
+ * after delivery are the measurement.
+ */
+type AiVariantDifficulty = 'easier' | 'same' | 'harder';
+/**
+ * What the level covers, from the host's curriculum: grammar and vocabulary a
+ * learner has been taught, and topics to keep away from. Told to the model;
+ * the SDK does not check vocabulary.
+ */
+interface AiVariantLevelFacts {
+  grammar?: string[];
+  vocabulary?: string[];
+  avoidTopics?: string[];
+}
+/** Why `aiVariantsRequest` left an exemplar out: it cannot yield a sound variant. */
+type AiVariantSkipCode = 'variant_exemplar_unheard' | 'variant_exemplar_unseen' | 'variant_exemplar_incomplete' | 'variant_exemplar_timeline' | 'variant_exemplar_unsupported' | 'variant_exemplar_too_long';
+/** An exemplar left out of the facts, and why. The host keeps it, or asks a person. */
+interface AiVariantSkip {
+  /** Its index in the exemplars passed. */
+  exemplarIndex: number;
+  code: AiVariantSkipCode;
+  message: string;
+}
+/**
+ * What a variant must meet, computed from its exemplar, so that what the model
+ * is told and what `checkAiVariants` checks are one thing.
+ */
+interface AiVariantTargets {
+  /** The exemplar's type: an activity type, or `item-group`. */
+  type: string;
+  /**
+   * The counts to keep: `{ mode: 'single', options: 4, correct: 1 }`,
+   * `{ blanks: [{ oneWord: true, acceptedAnswers: [1, 3] }] }`,
+   * `{ gaps: [{ bank: 0 }, …], banks: [{ choices: 7 }] }`,
+   * `{ stimulus: 'audio', items: ['multiple-choice', …], speakers: 2, turns: [5, 8] }`.
+   */
+  structure: Readonly<Record<string, unknown>>;
+  /** Inclusive bounds, in words, for each text written: `{ 'stimulus.body': [162, 198], question: [6, 14] }`. */
+  lengths: Readonly<Record<string, [number, number]>>;
+  difficulty: AiVariantDifficulty;
+  /** Why this item moves, in the host's words. Present only when `difficulty` is not `same`. */
+  difficultyReason?: string;
+  /** The ways this type is made easier or harder, as sentences. Present only when `difficulty` is not `same`. */
+  levers?: string[];
+  /**
+   * For an item group whose items do not all move alike (`difficultyFor`
+   * names some of them): each item's own difficulty, by its index in `items`.
+   */
+  itemDifficulty?: {
+    item: number;
+    difficulty: AiVariantDifficulty;
+    difficultyReason?: string;
+    levers?: string[];
+  }[];
+  /** What the item critic finds in the exemplar: flaws the variant must not repeat. */
+  exemplarFindings: {
+    code: string;
+    message: string;
+  }[];
+}
+/** One exemplar as a model is given it. */
+interface AiVariantExemplarFacts {
+  /** Its index in the exemplars passed: what the variant names as its `exemplar`. */
+  exemplar: number;
+  type: string;
+  /**
+   * The exemplar in the shape a variant is written in: every word a learner
+   * reads or hears, which options are right, and each blank's answers. No ids,
+   * HTML, settings or addresses.
+   */
+  content: Readonly<Record<string, unknown>>;
+  /** What it tests, when the author said: the variant tests the same. */
+  learningObjectives?: string[];
+  targets: AiVariantTargets;
+}
+/**
+ * A picture an exemplar shows, for a host that attaches pictures to its call:
+ * in exemplar order, each with the `ref` the facts name it by.
+ */
+interface AiVariantImage {
+  ref: string;
+  exemplarIndex: number;
+  /** Where the picture is, from the exemplar. */
+  path: string[];
+  alt?: string;
+  url: string;
+}
+/**
+ * What a host's model is given to write variants of existing items: built by
+ * `aiVariantsRequest`, and by `aiVariantsRepairRequest` for a second pass.
+ *
+ * Only `feature`, `facts`, `shape` and, on a repair, `repair` are for the
+ * model. The rest is for `checkAiVariants`: the exemplars and the other forms
+ * as passed — answer keys and addresses included — and the host's settings.
+ */
+interface AiVariantsRequest {
+  feature: 'variant-generation';
+  facts: {
+    /** One per exemplar that can be varied, in paper order. One variant is written for each. */
+    exemplars: AiVariantExemplarFacts[];
+    /** The level, as the host names it (`CEFR B1`): every variant stays inside it. */
+    level: string;
+    locale?: string;
+    /** The default for every exemplar; each one's `targets.difficulty` says its own. */
+    difficulty: AiVariantDifficulty;
+    levelFacts?: AiVariantLevelFacts;
+    /**
+     * What happens to a picture: `describe` — the variant describes a new one
+     * in its `alt`, for a person to find or commission; `reuse` — the variant
+     * keeps the exemplar's and asks new questions about it.
+     */
+    imagePolicy: 'describe' | 'reuse';
+    /** Every picture the exemplars show, for a host that attaches them. Absent when there are none. */
+    images?: AiVariantImage[];
+    /**
+     * The other forms' items, as their texts and right answers: what a variant
+     * must not resemble. Absent when the host passed none.
+     */
+    avoid?: {
+      texts: string[];
+      keys: string[];
+    }[];
+    /** The author's words to the model, as they are. */
+    instructions?: string;
+    /** What every variant must respect, as sentences a prompt can quote. */
+    rules: string[];
+  };
+  /** The JSON Schema of a reply — `{ variants: [...] }` — one per exemplar in the facts. */
+  shape: Readonly<Record<string, unknown>>;
+  /** The exemplars as passed. Not for the model: it holds answer keys and addresses. */
+  exemplars: readonly unknown[];
+  /** The other forms as passed. Not for the model. */
+  avoid?: readonly unknown[];
+  /** The host's settings for every variant of a type. Not for the model. */
+  settings?: AiDraftSettings;
+  /** The host's length ratios, overriding `AI_VARIANT_LENGTH_BANDS`. Not for the model. */
+  lengthTolerance?: {
+    material?: number;
+    item?: number;
+  };
+  /** Spread single-answer keys across positions, from this seed. Not for the model. */
+  balanceKeyPositions?: {
+    seed: string;
+  };
+  /** The exemplars that cannot be varied, and why. */
+  skipped: AiVariantSkip[];
+  /**
+   * On a repair: what to write again, each with the problems the model can
+   * fix — `variant` absent for one the model did not write. The reply holds
+   * one variant for each, naming its exemplar.
+   */
+  repair?: {
+    exemplar: number;
+    variant?: Readonly<Record<string, unknown>>;
+    problems: AiDraftProblem[];
+  }[];
+}
+/**
+ * Why a variant is not a parallel item of its exemplar: `variant_type` — not
+ * its type; `variant_structure` — a count a learner answers, or a setting that
+ * scores it, differs. Always `invalid`, and repairable.
+ */
+interface AiVariantMismatch {
+  path: string[];
+  message: string;
+  code: 'variant_type' | 'variant_structure';
+  severity: 'invalid';
+}
+/** An exemplar the reply wrote no variant for. Invalid, and repairable. */
+interface AiVariantMissing {
+  exemplarIndex: number;
+  code: 'variant_missing';
+  message: string;
+  severity: 'invalid';
+}
+/**
+ * One item of an exemplar and the variant's item in its place, by path from
+ * each entry (`[]` for a loose activity or a group, `['items', '2']` for an
+ * item in it) and by id: what lines up one form's slot with another's when
+ * the content has no `slotKey`.
+ */
+interface AiVariantPair {
+  exemplarPath: string[];
+  variantPath: string[];
+  exemplarId: string;
+  variantId: string;
+}
+/** A variant as the SDK made it from a reply: copied fields put back, ids minted, checked and compared. */
+interface AiGeneratedVariant {
+  /** Its exemplar's index in the exemplars passed. */
+  exemplarIndex: number;
+  /** The exemplar's type: an activity type, or `item-group`. */
+  type: string;
+  /** The variant: a sequence entry once `status` is `complete`. */
+  entry: Record<string, unknown>;
+  /**
+   * `invalid` when `validation` is, or a mismatch says so; else `incomplete`
+   * when `validation` is; else `complete`. A recording, or a picture to
+   * describe, comes back with no file — `media_url_required`, so `incomplete`
+   * — until the host attaches one.
+   */
+  status: 'complete' | 'incomplete' | 'invalid';
+  /** What `validateDraft`, or `validateItemGroupDraft`, says of it. */
+  validation: DraftValidationResult<unknown>;
+  /** How it fails to be parallel to its exemplar. */
+  mismatches: AiVariantMismatch[];
+  /** What the item critic finds, then `variant_length`, `variant_near_copy` and `variant_same_key`. */
+  findings: ItemFinding[];
+  /** Each item of the exemplar with the variant's item in its place. */
+  pairs: AiVariantPair[];
+  /** The variant as the model wrote it, for a repair. */
+  generated: Readonly<Record<string, unknown>>;
+}
+/** What `checkAiVariants` makes of a reply. */
+interface AiVariants {
+  /** The variants the reply wrote, in exemplar order. */
+  variants: AiGeneratedVariant[];
+  /** The exemplars it wrote none for. */
+  missing: AiVariantMissing[];
+  /** What only the set shows, over the variants as returned: the paper codes of `critiqueDrafts`. */
+  findings: ItemFinding[];
+  provenance?: AiProvenance;
+  usage?: GraderUsage;
+}
+/** What `generateVariants` came to. */
+interface AiVariantsRun {
+  /** The best pass of each variant, in exemplar order. */
+  variants: AiGeneratedVariant[];
+  /** The exemplars no pass wrote a variant for. */
+  missing: AiVariantMissing[];
+  /** What only the set shows, over the variants as they ended. */
+  findings: ItemFinding[];
+  /** The exemplars that could not be varied, and why. */
+  skipped: AiVariantSkip[];
+  /** Every call, in order: the first, then each repair. */
+  calls: AiDraftsCall[];
+}
+export { AiTextResult as $, GradeRoutingReason as $n, DictationEquivalence as $t, AiGapSelectFacts as A, ScoringOutcome as An, TimelineCue as At, AiGroupInput as B, XAPIActor as Bn, VersionFinding as Bt, AiDraftsCall as C, ReadAloudDimension as Cn, MediaTimeline as Ct, AiFeature as D, RecordingBounds as Dn, Stimulus as Dt, AiExplanationRequest as E, ReadAloudSlowMedia as En, SequenceSlotGroup as Et, AiGradingCriterionFact as F, WrittenResponseData as Fn, DraftSeverity as Ft, AiOptionFact as G, XAPIObject as Gn, ActivityFeedback as Gt, AiItemFacts as H, XAPIContext as Hn, VersionSlot as Ht, AiGradingFacts as I, WrittenResponseLearnerResponse as In, DraftValidationResult as It, AiReadingWordFact as J, XAPIStatement as Jn, ActivityType as Jt, AiProvenance as K, XAPIResult as Kn, ActivityMedia as Kt, AiGradingJudgement as L, WrittenResponseRubric as Ln, ItemFinding as Lt, AiGeneratedVariant as M, ScriptTurn as Mn, DraftContext as Mt, AiGrade as N, ValidationError as Nn, DraftIssue as Nt, AiFillInTheBlanksFacts as O, RecordingRef as On, StimulusKind as Ot, AiGradedCriterion as P, ValidationResult as Pn, DraftNotComplete as Pt, AiSupportedActivityType as Q, GradeRouting as Qn, DictationData as Qt, AiGradingRequest as R, WrittenResponseRubricCriterion as Rn, ItemFindingSeverity as Rt, AiDrafts as S, ReadAloudData as Sn, MediaProgress as St, AiDraftsRun as T, ReadAloudLearnerResponse as Tn, SequenceSlot as Tt, AiMaterialFacts as U, XAPIContextActivities as Un, ActivityData as Ut, AiHintRequest as V, XAPIConfig as Vn, VersionPaper as Vt, AiMultipleChoiceFacts as W, XAPIError as Wn, ActivityDataMap as Wt, AiRubricCriterionFact as X, CriterionScore as Xn, DeferredReason as Xt, AiRefusal as Y, XAPIVerbObject as Yn, BlankConfig as Yt, AiSoundFact as Z, GradeRecord as Zn, DeferredScoringPartial as Zt, AiDraftCaption as _, MultipleChoiceData as _n, AiWritingFacts as _t, AiCoachingRequest as a, GapSelectBank as an, InlineCorrection as ar, AiVariantMissing as at, AiDraftSource as b, MultipleChoiceOptionMedia as bn, AiWritingFeedbackResult as bt, AiCriterionJudgement as c, GapSelectGap as cn, levenshteinDistance as cr, AiVariantSkipCode as ct, AiCritiqueFinding as d, InteractionKind as dn, AiVariantsRequest as dt, DictationLearnerResponse as en, Grader as er, AiVariantDifficulty as et, AiCritiqueFindingResult as f, ItemOutcome as fn, AiVariantsRun as ft, AiDictationFacts as g, MediaTrack as gn, AiWritingCorrection as gt, AiCritiqueResult as h, MediaPlaybackPolicy as hn, AiWordFact as ht, AiCoaching as i, FillInTheBlanksLearnerResponse as in, GradingState as ir, AiVariantMismatch as it, AiGeneratedDraft as j, ScoringResult as jn, DraftComplete as jt, AiGapFact as k, ScoringDetail as kn, TimelineChapter as kt, AiCritique as l, GapSelectLearnerResponse as ln, matchText as lr, AiVariantTargets as lt, AiCritiqueRequest as m, LearnerResponseMap as mn, AiVideoDraft as mt, AiActivityInput as n, DictationTolerance as nn, GraderKind as nr, AiVariantImage as nt, AiCoachingResult as o, GapSelectChoice as on, TextMatchPolicy as or, AiVariantPair as ot, AiCritiqueKind as p, LearnerResponse as pn, AiVerdict as pt, AiReadingFacts as q, XAPIScore as qn, ActivityResult as qt, AiBlankFact as r, FillInTheBlanksData as rn, GraderUsage as rr, AiVariantLevelFacts as rt, AiCoachingWord as s, GapSelectData as sn, TextMatchResult as sr, AiVariantSkip as st, ActivityAiPermissions as t, DictationSlowMedia as tn, GraderConfiguration as tr, AiVariantExemplarFacts as tt, AiCritiqueField as u, InteractionEvent as un, AiVariants as ut, AiDraftProblem as v, MultipleChoiceLearnerResponse as vn, AiWritingFeedback as vt, AiDraftsRequest as w, ReadAloudDimensionWeight as wn, SequenceEntry as wt, AiDraftType as x, NativeControlHint as xn, ItemGroup as xt, AiDraftSettings as y, MultipleChoiceOption as yn, AiWritingFeedbackRequest as yt, AiGradingRequestProblem as z, WrittenResponseRubricLevel as zn, VersionComparison as zt };
+//# sourceMappingURL=ai-Cnm0qE8v.d.ts.map

package/dist/ai-Cnm0qE8v.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ai-Cnm0qE8v.d.ts","names":[],"sources":["../src/scoring/text-match.ts","../src/types/grading.ts","../src/types/xapi.ts","../src/types/activity.ts","../src/types/authoring.ts","../src/types/item-group.ts","../src/types/ai.ts"],"mappings":"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"}

package/dist/ai-check.cjs

@@ -1,7 +1,7 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_ai_writing = require("./ai-writing-C4YRVrFi.cjs");
-const require_scoring = require("./scoring-CaPS6q8b.cjs");
-//#region src/ai-check/cases.ts
+const require_ai_writing = require("./ai-writing-Bh2Y53cY.cjs");
+const require_scoring = require("./scoring-D9tFvPEG.cjs");
+// src/ai-check/cases.ts
 /**
 * The items the cases are built from. Small, ordinary language-course content
 * — and deliberately awkward in the places a model slips:
@@ -18,6 +18,8 @@ const require_scoring = require("./scoring-CaPS6q8b.cjs");
 * - questions in item groups: a reading passage that prints a question's
 *   answer, which a hint must point to without quoting, and a run of blanks
 *   whose instructions only the group states;
+* - the same blank served alone, as an adaptive test serves it, whose task
+*   only its own instructions state;
 * - essays to grade on a rubric of three criteria, two judged on levels and
 *   one on a score, so a grade that drops a criterion or leaves a scale is
 *   caught.
@@ -181,6 +183,12 @@ const formationPart = {
 	},
 	items: [formation]
 };
+/** The same blank served alone, as an adaptive test serves it: the task is in its own instructions. */
+const formationAlone = {
+	...formation,
+	id: "ai-check-formation-alone",
+	instructions: "Use the word in capitals at the end of the sentence to form a word that fits the gap."
+};
 const weekend = {
 	schemaVersion: "1.0",
 	type: "written-response",
@@ -548,6 +556,49 @@ function draftsCase(id, about, types, source, extra = {}) {
 		request
 	};
 }
+/** Builds a variants case, failing loudly rather than shipping one with nothing to vary. */
+function variantsCase(id, about, exemplars, extra = {}) {
+	const request = require_ai_writing.aiVariantsRequest({
+		exemplars,
+		level: "CEFR A2",
+		...extra
+	});
+	if (request.facts.exemplars.length !== exemplars.length) throw new Error(`ai-check: an exemplar of "${id}" cannot be varied`);
+	return {
+		id,
+		feature: "variant-generation",
+		about,
+		request
+	};
+}
+/** A text everyone has read: a model is tempted to copy it rather than write a parallel one. */
+const famous = {
+	schemaVersion: "1.0",
+	type: "read-aloud",
+	id: "ai-check-famous",
+	title: "Read the opening aloud",
+	referenceText: "It was the best of times, it was the worst of times, it was the age of wisdom.",
+	locale: "en-US",
+	recording: { maxSeconds: 20 },
+	scoring: { dimensions: [{
+		name: "accuracy",
+		weight: 1
+	}] }
+};
+/** A grammar item whose only natural answer, in any parallel sentence, is the same word. */
+const secondConditional = {
+	schemaVersion: "1.0",
+	type: "fill-in-the-blanks",
+	id: "ai-check-second-conditional",
+	title: "If I were you",
+	instructions: "Complete the sentence. Use ONE word.",
+	passage: "If I {{be}} you, I would take the early train tomorrow.",
+	blanks: [{
+		id: "be",
+		acceptedAnswers: ["were"]
+	}],
+	scoringStrategy: "all-or-nothing"
+};
 /**
 * What a host sets on every read-aloud it drafts: the SDK has no default for a
 * recording's length or the dimensions a reading is graded on.
@@ -706,6 +757,7 @@ function aiCheckCases() {
 		hintCase("gap-hint-2", "Asked again with the first gap wrong", landscape, picked({ g1: "campo" }), ["Piensa en la forma del terreno."]),
 		hintCase("mc-reading-hint", "Has not answered a question whose answer its group's passage prints", springTides, chose([]), [], tides),
 		hintCase("fib-formation-hint", "A word-formation blank, under the instructions its group gives", formation, typed({}), [], formationPart),
+		hintCase("fib-instructions-hint", "The same blank served alone, under its own instructions", formationAlone, typed({})),
 		writingCase("writing-mistakes", "A first draft with tense, article and agreement mistakes", "Last weekend I go to the market and buyed a apple. My friends was there too, so we don't go home early. Then I go to the cinema."),
 		writingCase("writing-clean", "A first draft with no mistakes to correct", "Last weekend I went to the market and bought an apple. My friends were there too, so we stayed until the evening. Then we went to the cinema."),
 		writingCase("writing-revised", "A second draft that fixed some mistakes", "Last weekend I went to the market and bought a apple. My friends was there too, so we didn't go home early.", ["Check your past tenses: \"go\" and \"buyed\" should be past forms."]),
@@ -790,11 +842,27 @@ function aiCheckCases() {
 			data: tidesSummaryExam,
 			group: tidesExam
 		}),
-		gradingCase("grading-in-spanish", "The essay with mistakes, with comments asked for in Spanish", "Last weekend I go to the market and buyed a apple. My friends was there too, so we don't go home early. Then I go to the cinema.", { learnerLocale: "es" })
+		gradingCase("grading-in-spanish", "The essay with mistakes, with comments asked for in Spanish", "Last weekend I go to the market and buyed a apple. My friends was there too, so we don't go home early. Then I go to the cinema.", { learnerLocale: "es" }),
+		variantsCase("variants-choice", "A parallel version of a multiple choice", [capital]),
+		variantsCase("variants-cloze", "A parallel version of a fill-in-the-blanks", [introduction]),
+		variantsCase("variants-gaps", "A parallel version of a gap select", [landscape]),
+		variantsCase("variants-dictation", "A parallel version of a dictation", [listening]),
+		variantsCase("variants-read-aloud", "A parallel version of a text to read aloud", [weather]),
+		variantsCase("variants-writing", "A parallel version of a writing task", [weekend]),
+		variantsCase("variants-reading", "A parallel reading part: a new passage and its questions", [tides]),
+		variantsCase("variants-section", "A parallel section, harder by one step, with its keys spread", [
+			capital,
+			introduction,
+			landscape
+		], {
+			difficulty: "harder",
+			balanceKeyPositions: { seed: "ai-check" }
+		}),
+		variantsCase("variants-famous", "A parallel version of a famous opening line", [famous]),
+		variantsCase("variants-grammar-key", "A parallel grammar item whose natural answer is the same word", [secondConditional])
 	];
 }
-//#endregion
-//#region src/ai-check/index.ts
+// src/ai-check/index.ts
 /**
 * A test kit for the prompts behind your AI ports.
 *
@@ -861,6 +929,7 @@ function portFor(ports, one) {
 		case "pronunciation-coaching": return ports.pronunciationCoaching;
 		case "item-critique": return ports.critique;
 		case "draft-generation": return ports.drafts;
+		case "variant-generation": return ports.variants;
 		case "grading": return ports.grading;
 		default: return ports.writingFeedback;
 	}
@@ -906,6 +975,19 @@ async function runCase(ports, one) {
 			ms
 		} : refused(one, raw, checked.refusal, ms);
 	}
+	if (one.request.feature === "variant-generation") {
+		let next = 0;
+		const checked = require_ai_writing.checkAiVariants(raw, one.request, { newId: () => {
+			next += 1;
+			return `ai-check-${next}`;
+		} });
+		return checked.ok ? {
+			case: one,
+			ok: true,
+			variants: checked.variants,
+			ms
+		} : refused(one, raw, checked.refusal, ms);
+	}
 	if (one.request.feature === "item-critique") {
 		const checked = require_ai_writing.checkAiCritique(raw, one.request);
 		return checked.ok ? {
@@ -1037,7 +1119,6 @@ function formatAiCheckReport(report) {
 	}
 	return lines.join("\n");
 }
-//#endregion
 exports.aiCheckCases = aiCheckCases;
 exports.formatAiCheckReport = formatAiCheckReport;
 exports.runAiCheck = runAiCheck;