@intellectif/lk-core 1.6.0 → 1.8.0

package/CHANGELOG.md

@@ -1,5 +1,41 @@
 # @intellectif/lk-core
 
+## 1.8.0
+
+### Minor Changes
+
+- [#132](https://github.com/intellectif/learning-kit/pull/132) [`6abddb4`](https://github.com/intellectif/learning-kit/commit/6abddb4e9f2f8ebe0b2136581c19177a61702b7b) Thanks [@diego28e](https://github.com/diego28e)! - **Parallel forms of an exam: a model writes variants of existing items, the critic reads a whole paper, and `critiqueVersions` compares two forms**
+
+  **Action required:** none. Everything is new except `critiqueDrafts`, which now also reports the paper codes below over every item of a set, groups' items included: an editor that lists findings shows them, and translates them by `code` like any other.
+
+  - **`aiVariantsRequest`, `checkAiVariants`, `aiVariantsRepairRequest`, `generateVariants`**, the shape of the drafting functions: a model writes a parallel version of each exemplar — loose items and whole parts, a new passage or listening script included — keeping its type, structure, scoring and settings, which the SDK copies back whatever the reply says. Each exemplar's facts carry targets the SDK computed (counts, lengths in words, difficulty and its levers), and each variant comes back with a status, `mismatches` (`variant_type`, `variant_structure`), findings (`variant_length`, `variant_near_copy`, `variant_same_key`, against the exemplar and every other form) and `pairs` lining its items up with the exemplar's. A recording comes back with no file and its new script; a picture is described anew or reused. Exemplars that cannot be varied are listed in `skipped`; `balanceKeyPositions` spreads single-answer keys from a seed.
+  - **The paper critic:** `set_key_position_bias`, `set_key_longest_bias`, `set_stem_duplicate`, `set_item_answers_item` and `set_key_repeated`, each naming the other items involved in the new `related` of a finding; and `fib_tolerance_spans_words`, for a blank whose forgiven edits run over an answer of several words.
+  - **`critiqueVersions(a, b)`:** two forms slot by slot — paired by given pairs, `slotKey` or position — for blueprint, type, structure, objectives and length, and paper against paper for near copies, shared keys and shared files.
+  - **`vectors/variants.json`** with `vectors/variants.mjs`: requests, canned replies and outcomes to replay against the build you install; the AI check kit gains a `variants` port and ten cases.
+  - **Why a minor:** additive. No scoring, validation or stored content changes.
+
+  Guide: https://github.com/intellectif/learning-kit/blob/main/docs/ai.md#variants-of-existing-items-18
+
+## 1.7.0
+
+### Minor Changes
+
+- [#122](https://github.com/intellectif/learning-kit/pull/122) [`4f59f0a`](https://github.com/intellectif/learning-kit/commit/4f59f0aee1868875a729af89a7ae275ff96bb218) Thanks [@diego28e](https://github.com/diego28e)! - **A question's own instructions**: multiple choice, fill in the blanks and gap select take an optional `instructions`, the task the learner reads before answering, as read aloud already does.
+
+  **Action required:** none, unless you already store a field under this name. Content is loose, so an `instructions` of your own on these three types validated before. It now has to be a string, and on a fill in the blanks or a gap select it may hold no `{{id}}` placeholder. Anything else fails validation at `instructions`. **No grade changes:** no scorer reads it, and the grade-stability corpus is unchanged.
+
+  - **What it is for:** "Complete the sentence. Use ONE word.", on a question served alone (an adaptive test's, or a bank shuffled across forms) where no item group can hold it. Instructions a run of questions shares stay in the group's text stimulus.
+  - **lk-core:**
+    - **The field.** `instructions?: string` on `MultipleChoiceData`, `FillInTheBlanksData` and `GapSelectData`, plain text. A `{{id}}` placeholder in a fill in the blanks' or a gap select's instructions is refused at `instructions`, since blanks and gaps live in the passage only.
+    - **Learner-visible.** `redact()` keeps it at every reveal level, and so do `withoutAuthorOnly()` and `redactItemGroup()`. `assertRedacted()` accepts it, and the `Redacted*` types carry it.
+    - **Schemas.** `jsonSchemaFor()` and `contentJsonSchema()` describe it.
+    - **AI help.** Hint and explanation facts carry `instructions` on these types, trimmed, apart from the question or the passage. A grouped question carries both its group's `material` and its own instructions. Tell your model that they are the task, not part of the text answered.
+    - **Drafts.** A model drafting these types may write `instructions`, and `checkAiDrafts` keeps them.
+    - **`@intellectif/lk-core/ai-check`** has one more case, `fib-instructions-hint`: the word-formation blank of `fib-formation-hint` served alone, with its task in its own instructions.
+  - **lk-react:** `<MultipleChoice>`, `<FillInTheBlanks>` and `<GapSelect>` draw the instructions first, before the media and the question or passage, in `.lk-mc-instructions`, `.lk-fib-instructions` or `.lk-gs-instructions`. The question's fieldset names them with `aria-describedby`. Blank instructions draw nothing. Inside `<ActivitySequence>`, a grouped question shows its group's material, then its own instructions. lk-react 23.3.0 peers on lk-core `^1.7.0`, so upgrade the two together.
+
+  Guide: https://github.com/intellectif/learning-kit/blob/main/docs/authoring.md#a-questions-own-instructions-17
+
 ## 1.6.0
 
 ### Minor Changes

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

@@ -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.ts.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.cts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ai-Cnm0qE8v.d.cts","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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"}