@intellectif/lk-core 1.4.0 → 1.6.0

package/dist/{index-B54baFUA.d.ts → index-CFRgZLhH.d.cts}

@@ -1,4 +1,4 @@
-import { St as ActivityMedia, Xt as MultipleChoiceOptionMedia, bt as ActivityDataMap, ln as ValidationResult, tt as ItemGroup, wt as ActivityType } from "./ai-CnmLPMzd.js";
+import { At as ActivityType, Et as ActivityDataMap, Ot as ActivityMedia, gn as ValidationResult, nn as MultipleChoiceOptionMedia, st as ItemGroup } from "./ai-i3jwXnpX.cjs";
 //#region src/types/redacted.d.ts
 /**
  * The learner-safe SHAPE of each built-in type.
@@ -110,6 +110,10 @@ interface RedactedWrittenResponseData extends RedactedItem {
       name: string;
       weight: number;
       description?: string | undefined;
+      levels?: {
+        label: string;
+        description?: string | undefined;
+      }[] | undefined;
     }[];
     label?: string | undefined;
   } | undefined;
@@ -284,22 +288,51 @@ declare const fillInTheBlanksJsonSchema: Record<string, unknown>;
  * contract. Structural contract only.
  */
 declare const writtenResponseJsonSchema: Record<string, unknown>;
+/** The JSON Schema drafts the SDK writes. */
+type JsonSchemaTarget = 'draft-2020-12' | 'draft-7';
 /**
- * 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.
+ * Derives the JSON Schema 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.
+ * Draft 7 unless `target` says `'draft-2020-12'`. For a type you registered,
+ * it is the descriptor's `jsonSchema` when you gave one, in whatever draft you
+ * wrote it, or else what the schema produces through the Standard JSON Schema
+ * converter (`'~standard'.jsonSchema`) in the draft asked for — 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>;
+declare function jsonSchemaFor(type: string, options?: {
+  target?: JsonSchemaTarget;
+}): Record<string, unknown>;
+/**
+ * One JSON Schema document for content an outside tool writes: the root is a
+ * `SequenceEntry` — an activity of any registered type, or an item group whose
+ * items are typed too. Each type, the stimulus and the item group sit under
+ * `$defs` (`definitions` in draft 7), so a tool can also point at one of them.
+ * Draft 2020-12 unless `target` says `'draft-7'`.
+ *
+ * Structural, as every exported schema is: rules that span fields (one key in
+ * a single-answer question, a blank for each marker, a slow recording that is
+ * another file) cannot be written in JSON Schema. On import, `validateDraft`
+ * and `validateItemGroupDraft` decide. It includes the author-only fields
+ * (`transcript`, `script`), so a tool can write them.
+ *
+ * ```ts
+ * writeFileSync('schema.json', JSON.stringify(contentJsonSchema(), null, 2));
+ * ```
+ */
+declare function contentJsonSchema(options?: {
+  target?: JsonSchemaTarget;
+}): Record<string, unknown>;
+//#endregion
+//#region src/schemas/media.d.ts
+/** The most turns a recording's `script` may hold. */
+declare const SCRIPT_MAX_TURNS = 500;
 //#endregion
 //#region src/schemas/index.d.ts
 /**
@@ -335,5 +368,5 @@ declare function validateOptionMedia(value: unknown): ValidationResult<MultipleC
  */
 declare function validateActivity<T extends ActivityType>(type: T, data: unknown): ValidationResult<ActivityDataMap[T]>;
 //#endregion
-export { RedactedMultipleChoiceData as C, RedactedStimulus as D, RedactedReadAloudData as E, RedactedWrittenResponseData as O, RedactedGapSelectGap as S, RedactedMultipleChoiceOptionMedia as T, RedactedDictationSlowMedia as _, fillInTheBlanksJsonSchema as a, RedactedGapSelectChoice as b, jsonSchemaFor as c, stimulusJsonSchema as d, writtenResponseJsonSchema as f, RedactedDictationData as g, RedactedBlankConfig as h, dictationJsonSchema as i, multipleChoiceJsonSchema as l, RedactedActivity as m, validateMedia as n, gapSelectJsonSchema as o, validateItemGroup as p, validateOptionMedia as r, itemGroupJsonSchema as s, validateActivity as t, readAloudJsonSchema as u, RedactedFillInTheBlanksData as v, RedactedMultipleChoiceOption as w, RedactedGapSelectData as x, RedactedGapSelectBank as y };
-//# sourceMappingURL=index-B54baFUA.d.ts.map
+export { RedactedStimulus as A, RedactedGapSelectChoice as C, RedactedMultipleChoiceOption as D, RedactedMultipleChoiceData as E, RedactedMultipleChoiceOptionMedia as O, RedactedGapSelectBank as S, RedactedGapSelectGap as T, RedactedActivity as _, JsonSchemaTarget as a, RedactedDictationSlowMedia as b, fillInTheBlanksJsonSchema as c, jsonSchemaFor as d, multipleChoiceJsonSchema as f, validateItemGroup as g, writtenResponseJsonSchema as h, SCRIPT_MAX_TURNS as i, RedactedWrittenResponseData as j, RedactedReadAloudData as k, gapSelectJsonSchema as l, stimulusJsonSchema as m, validateMedia as n, contentJsonSchema as o, readAloudJsonSchema as p, validateOptionMedia as r, dictationJsonSchema as s, validateActivity as t, itemGroupJsonSchema as u, RedactedBlankConfig as v, RedactedGapSelectData as w, RedactedFillInTheBlanksData as x, RedactedDictationData as y };
+//# sourceMappingURL=index-CFRgZLhH.d.cts.map

package/dist/index-CFRgZLhH.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index-CFRgZLhH.d.cts","names":[],"sources":["../src/types/redacted.ts","../src/schemas/item-group.ts","../src/schemas/json-schema.ts","../src/schemas/media.ts","../src/schemas/index.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;UAoBU;EACR;EACA;EACA;EACA;EACA;;;UAIQ;EACR;EACA;EACA;EACA;EACA;;;UAIQ;EACR;EACA;EACA;EACA;EACA,SAAS;EACT;EACA,WAAW;;;UAIH;EACR;EACA;;;UAIQ;EACR;EACA;EACA;EACA;EACA;EACA,QAAQ;EACR;EACA;EACA;EACA,KAAK;;;UAIU;EACf;EACA;EACA;EACA;;;UAIe;EACf;EACA;EACA,QAAQ;;;UAIO,mCAAmC;EAClD;EACA;EACA;EACA;EACA,SAAS;EACT;EACA;;;UAIe;EACf;EACA;;;UAIe,oCAAoC;EACnD;EACA;EACA;EACA,QAAQ;EACR;;;UAIe,oCAAoC;EACnD;EACA;EACA;EACA;EACA;EACA;IAEM;MACE;MACA;MACA;MACA;QAAW;QAAe;;;IAE5B;;EAGN;EACA;;;UAIe;EACf;EACA;;;UAIe;EACf;EACA,SAAS;;;UAIM;EACf;EACA,UAAU;EACV;;;UAIe,8BAA8B;EAC7C;EACA;EACA;EACA,MAAM;EACN,QAAQ;EACR;EACA;EACA;;;UAIe;EACf;EACA;EACA;;;UAIe,8BAA8B;EAC7C;EACA,YAAY;EACZ;IAAU;;EACV;;;;;;;UAQe,8BAA8B;EAC7C;EACA;EACA;EACA;EACA,YAAY;EACZ;IACE;IACA;IACA;;EAEF;IACE;MACE;MACA;;;;;UAMW;EACf;EACA;EACA;EACA;EACA;EACA,QAAQ;EACR;EACA;;;;;;;;;;;;;;KAeU,mBACR,6BACA,8BACA,8BACA,wBACA,wBACA;;;;;;;;;;;;;iBC4MY,kBAAkB,gBAAgB,iBAAiB;;;;;;;cCnatD,oBAAoB;;;;;;;;cAWpB,qBAAqB;;;;;;;;;;;;;;;;;;cAqBrB,qBAAqB;;;;;;;;;;;cAcrB,qBAAqB;;;;;;;;;;cAarB,qBAAqB;cAIrB,0BAA0B;;;;;;cAY1B,2BAA2B;;;;;cAW3B,2BAA2B;;KAQ5B;;;;;;;;;;;;;;;;;iBAqBI,cACd,cACA;EAAW,SAAS;IACnB;;;;;;;;;;;;;;;;;;iBA4Ca,kBACd;EAAW,SAAS;IACnB;;;;cCzEU;;;;;;;;;;;;;iBCnDG,cAAc,iBAAiB,iBAAiB;;;;;;;;iBAWhD,oBAAoB,iBAAiB,iBAAiB;;;;;;;;;;;;;iBA8BtD,iBAAiB,UAAU,cACzC,MAAM,GACN,gBACC,iBAAiB,gBAAgB"}

package/dist/{index-CVWvymVb.d.ts → index-DeD8EI1D.d.ts}

@@ -1,4 +1,4 @@
-import { En as Grader, Ht as ItemOutcome, Ot as DictationData, Qt as ReadAloudData, Tn as GradeRecord, Ut as LearnerResponse, ln as ValidationResult, sn as ScoringResult, tn as ReadAloudLearnerResponse, wt as ActivityType, yt as ActivityData } from "./ai-CnmLPMzd.js";
+import { At as ActivityType, I as AiGradingJudgement, In as Grader, Jt as ItemOutcome, Ln as GraderConfiguration, Mn as CriterionScore, Nn as GradeRecord, Pn as GradeRouting, Pt as DictationData, Tt as ActivityData, Yt as LearnerResponse, _n as WrittenResponseData, gn as ValidationResult, in as ReadAloudData, pn as ScoringResult, sn as ReadAloudLearnerResponse, yn as WrittenResponseRubric } from "./ai-i3jwXnpX.js";
 //#region src/scoring/rounding.d.ts
 /**
  * Rounding for assessment scores.
@@ -564,6 +564,330 @@ interface ItemTriesScore {
   tries: ItemTryScore[];
 }
 //#endregion
+//#region src/grading.d.ts
+/** Options for {@link gradeFromRubric}. */
+interface GradeFromRubricOptions {
+  /**
+   * Scaled score [0,1] required to pass. Defaults to the activity's
+   * `passThreshold`, or {@link DEFAULT_PASS_THRESHOLD} when absent.
+   */
+  passThreshold?: number;
+  /** Narrative feedback for the learner, carried onto the record verbatim. */
+  feedback?: string | null;
+  /**
+   * Compare the pass line the way the score is displayed — both sides rounded,
+   * via `gte` — whichever threshold applies: `passThreshold` above, the
+   * activity's own, or the 0.7 default. The returned `score` stays unrounded.
+   * Opt-in, as on `score()` and `evaluate()`: switching it on moves pass/fail
+   * for totals in the rounding band.
+   *
+   * Checked before any criterion is read: `null` reads as no policy, and a
+   * policy that cannot be applied — an unknown `mode`, or a `dp` that is not a
+   * whole number from 0 to 15 — throws a `RangeError`, even for a rubric that
+   * turns out to be unscorable.
+   */
+  rounding?: RoundingPolicy;
+}
+/**
+ * Computes the weighted total from per-criterion scores — the arithmetic that
+ * must NOT be delegated to a language model.
+ *
+ * A grader is asked for judgement (how good is this criterion?), not for
+ * mental arithmetic. Asking a model to also produce the weighted total makes
+ * the final grade unverifiable and unreproducible: two runs can return
+ * different totals for identical criterion scores. This function makes the
+ * total a pure function of the judgements, so a grade can be recomputed and
+ * audited years later.
+ *
+ * Weights are normalised by their sum, so they need not add to 1; each must be
+ * zero or more, and their sum a positive, finite number, or the result is
+ * `unscorable`. Criteria marked `notApplicable`, and those carrying no numeric
+ * `score` (a purely banded judgement), are excluded from both numerator and
+ * denominator, weight included. When nothing scoreable remains the result is
+ * `unscorable`, never a zero.
+ *
+ * Scores need not be in [0,1]: set `maxScore` on a criterion to declare what
+ * its score is out of, and each is normalised before weighting. A grader
+ * working out of 100 says so and is done:
+ *
+ * ```ts
+ * gradeFromRubric([
+ *   { name: 'Task achievement', score: 82, maxScore: 100, weight: 2 },
+ *   { name: 'Range',            score: 7,  maxScore: 9,   weight: 1 },
+ * ]);
+ * ```
+ *
+ * The returned `GradeRecord.score` is always scaled [0,1] against
+ * `maxScore: 1`, like every other score in the SDK.
+ */
+declare function gradeFromRubric(criteria: readonly CriterionScore[], activityData?: ActivityData, options?: GradeFromRubricOptions): GradeRecord | {
+  unscorable: true;
+  reason: string;
+};
+/**
+ * Lifts a {@link GradeRecord} into the `graded` arm of {@link ItemOutcome}, so
+ * a grade that arrived asynchronously renders through the same path as a
+ * synchronously scored item. The score/passed/feedback fields are mirrored
+ * onto the outcome for uniform reads; `grade` carries the full record.
+ *
+ * A record whose numbers cannot be a grade is refused, as `evaluate` refuses a
+ * non-finite score and {@link gradeFromRubric} one outside [0,1]. `maxScore`
+ * must be a positive, finite number and `score` a finite number from 0 to it (a
+ * hair above, one part in a billion, is float noise and passes as it is).
+ * Anything else — NaN, 85 "out of 1", a score out of 0 — comes back as
+ * `{ status: 'deferred', reason: 'grade_rejected', maxScore: 1, rejectedGrade }`
+ * with the record kept verbatim. Not `graded`, or its `passed` would be read as
+ * a verdict; not `unscorable`, which `composeAssessmentScore` drops from the
+ * denominator while letting the attempt go final — so a failing grade on the
+ * wrong scale would vanish and the rest would be recorded as a pass. Deferred
+ * is what it is: the slot is still owed a real grade, so a composed attempt
+ * stays `provisional` and names the slot in `rejectedSlotIds`.
+ */
+declare function outcomeFromGrade(grade: GradeRecord): ItemOutcome;
+/**
+ * True when an outcome carries a real grade — either the SDK scored it
+ * synchronously or a grader returned one. Use this instead of testing
+ * `status === 'scored'`, which silently misses asynchronously graded work.
+ */
+declare function hasGrade(outcome: ItemOutcome): outcome is Extract<ItemOutcome, {
+  status: 'scored' | 'graded';
+}>;
+//#endregion
+//#region src/scoring/assisted/calibration.d.ts
+/** One response marked twice: by the model, and by a person — and, optionally, a second person. */
+interface CalibrationPair {
+  /** The model's grade, from `gradeFromJudgement`: its `grader` names the model and the prompt. */
+  model: GradeRecord;
+  /** A person's grade of the same response, criterion by criterion. */
+  person: GradeRecord;
+  /** A second person's grade, for the human–human agreement a model is compared with. */
+  secondPerson?: GradeRecord;
+}
+/** What the responses were graded against: the rubric, and the target language. */
+interface CalibrationScope {
+  rubric?: WrittenResponseRubric;
+  languageTarget?: string;
+}
+/** How a model's judgements of one criterion agree with a person's. Rates are fractions from 0 to 1. */
+interface CriterionCalibration {
+  name: string;
+  /** `levels` when the criterion is judged on levels; `score` when on a score from 0 to 1. */
+  scale: 'levels' | 'score';
+  /** How many levels, on a criterion with levels. */
+  levels?: number;
+  /** Pairs where both judged this criterion on its scale. */
+  pairs: number;
+  /** Levels: the share of pairs on the same level. */
+  exactAgreement?: number | null;
+  /** Levels: the share of pairs at most one level apart. */
+  adjacentAgreement?: number | null;
+  /** Levels: Cohen's kappa, quadratic weights. `null` when it is undefined (no variance). */
+  quadraticKappa?: number | null;
+  /** Levels: pair counts, `confusion[personLevel][modelLevel]`, lowest first. */
+  confusion?: number[][];
+  /** Pearson's r between the two scores. `null` when undefined (fewer than 2 pairs, or no variance). */
+  pearson: number | null;
+  /** The mean absolute difference between the two scores, from 0 to 1. `null` with no pairs. */
+  meanAbsoluteError: number | null;
+  /**
+   * The model's mean score minus the person's, over their pooled standard
+   * deviation (population): positive when the model is more lenient. `null`
+   * when undefined.
+   */
+  standardizedMeanDifference: number | null;
+  /** Levels: pairs whose model grade carried level probabilities. */
+  probabilityPairs?: number;
+  /**
+   * Levels: expected calibration error over ten equal bins of the model's
+   * confidence (its likeliest level's probability): how far stated confidence
+   * is from how often that level was the person's. `null` without
+   * probabilities.
+   */
+  calibrationError?: number | null;
+  /** Levels: the multi-class Brier score of the probabilities against the person's level. `null` without them. */
+  brierScore?: number | null;
+  /** Pairs with a second person's grade of this criterion. */
+  humanPairs?: number;
+  /** Levels: quadratic kappa between the two people. */
+  humanQuadraticKappa?: number | null;
+  /** Pearson's r between the two people. */
+  humanPearson?: number | null;
+  /**
+   * How much worse the model agrees with a person than two people agree: the
+   * human kappa minus the model's on levels, the human r minus the model's on
+   * scores. `null` without a second person.
+   */
+  degradation?: number | null;
+}
+/** How the model's totals agree with a person's. */
+interface TotalCalibration {
+  pairs: number;
+  pearson: number | null;
+  meanAbsoluteError: number | null;
+  standardizedMeanDifference: number | null;
+  /** The share of pairs whose pass or fail is the same. */
+  passAgreement: number | null;
+  humanPairs?: number;
+  humanPearson?: number | null;
+  degradation?: number | null;
+}
+/**
+ * How one grader configuration agrees with people, on the host's own responses.
+ * It ships no thresholds: the host decides what agreement admits a model to a
+ * paper of record, and `routeGrade` applies that decision.
+ */
+interface CalibrationReport {
+  /** What this report certifies: one model, one prompt revision, one rubric, one target. */
+  configuration: GraderConfiguration;
+  /** Pairs given. */
+  pairs: number;
+  /** One entry per rubric criterion, in the rubric's order. */
+  criteria: CriterionCalibration[];
+  total: TotalCalibration;
+  /** `contentHash` of everything above: what a routed grade records it relied on. */
+  reportHash: string;
+}
+/** The grader configuration a model grade comes from, on items with this rubric and target; `null` when the grade does not name its model and prompt. */
+declare function graderConfiguration(grade: GradeRecord, scope: CalibrationScope): GraderConfiguration | null;
+/**
+ * How one grader configuration — a model, a prompt revision, a rubric and a
+ * target language — agrees with people, measured on responses the host had
+ * marked twice. Pure: the same pairs give the same report and the same
+ * `reportHash`.
+ *
+ * Every model grade must come from one configuration (its `grader` names the
+ * model and the prompt), and no person's grade may be a model's. A criterion
+ * is measured over the pairs where both judged it on its scale — levels by
+ * their labels, scores as fractions of their maximum — and every metric that
+ * is undefined is `null`, never a number made up. It ships no threshold:
+ * `routeGrade` applies the host's.
+ */
+declare function calibrationReport(pairs: readonly CalibrationPair[], scope: CalibrationScope): {
+  ok: true;
+  report: CalibrationReport;
+} | {
+  ok: false;
+  reason: string;
+};
+//#endregion
+//#region src/scoring/assisted/grade-from-judgement.d.ts
+/** Options for {@link gradeFromJudgement}: those of `gradeFromRubric`, but the feedback is the model's. */
+type GradeFromJudgementOptions = Omit<GradeFromRubricOptions, 'feedback'>;
+/**
+ * The grade a checked model judgement gives a written response: the total
+ * computed as `gradeFromRubric` computes every grade — never by the model — with
+ * the item's own weights and pass line, and the record a host keeps.
+ *
+ * Each criterion scores what `checkAiGrading` read: a level's place on its
+ * scale, or the model's score from 0 to 1. The level chosen is kept as `band`,
+ * its probabilities as `levelProbabilities`, and the model's identity as
+ * `grader` (`kind: 'ai'`, with its `model` and `promptHash`), so a routing rule
+ * and a calibration can read them later.
+ *
+ * `data` must be the item the request was built from: a judgement that names a
+ * criterion this rubric does not have, or leaves one of its criteria out, is
+ * `unscorable` rather than a grade on another task's rubric.
+ */
+declare function gradeFromJudgement(judgement: AiGradingJudgement, data: WrittenResponseData, options?: GradeFromJudgementOptions): GradeRecord | {
+  unscorable: true;
+  reason: string;
+};
+//#endregion
+//#region src/scoring/assisted/routing.d.ts
+/**
+ * The thresholds a calibration report must meet before a model's grade counts.
+ * The SDK has no default for any of them, as rounding has no default `dp`: a
+ * threshold you leave out is not checked. A metric a threshold needs that the
+ * report cannot give — a kappa with no variance, a degradation without a second
+ * person — fails it: what cannot be shown is not assumed.
+ */
+interface CalibrationThresholds {
+  /** Fewest pairs a criterion, and the total, must be measured on. */
+  minPairs?: number;
+  /** Lowest quadratic kappa, on each criterion with levels. */
+  minQuadraticKappa?: number;
+  /** Lowest exact agreement, on each criterion with levels. */
+  minExactAgreement?: number;
+  /** Lowest Pearson's r, on each criterion without levels and on the total. */
+  minPearson?: number;
+  /** Highest mean absolute error, on every criterion and the total. */
+  maxMeanAbsoluteError?: number;
+  /** Highest |standardised mean difference|, on every criterion and the total. */
+  maxAbsStandardizedMeanDifference?: number;
+  /** Highest degradation from human–human agreement, on every criterion and the total. */
+  maxDegradation?: number;
+  /** Highest expected calibration error, on each criterion with levels whose grades carry probabilities. */
+  maxCalibrationError?: number;
+}
+/** How `routeGrade` decides. Every part is optional and has no default. */
+interface GradeRoutingPolicy {
+  /** What a calibration must show. Read when a report is supplied. */
+  calibration?: CalibrationThresholds;
+  /**
+   * A criterion judged on levels whose chosen level the grader gave a lower
+   * probability than this goes to a person (`unsure`), and so does one whose
+   * grade carries no distribution to read: what cannot be shown is not assumed.
+   */
+  minLevelProbability?: number;
+  /** Send a grade whose grader's own `confidence` is `low` to a person (`low-confidence`). */
+  routeLowConfidence?: boolean;
+  /** Send this share of grades to a person too, chosen by `inAuditSample` (`audit-sample`). */
+  audit?: {
+    rate: number;
+    seed: string;
+  };
+}
+/** What `routeGrade` reads besides the grade. */
+interface GradeRoutingContext {
+  /** `exam` for a paper of record: a grade needs a matching calibration there (`no-calibration`). */
+  mode: 'exam' | 'practice';
+  /** The item graded: its rubric and target name the configuration a report must certify. */
+  item: CalibrationScope;
+  /** The calibration of this grader's configuration, when the host has one. */
+  calibration?: CalibrationReport;
+  policy?: GradeRoutingPolicy;
+  /** The response's stable identity — an attempt and slot — for the audit sample. Required with `policy.audit`. */
+  sampleKey?: string;
+}
+/**
+ * Whether `key` is in the audit sample: a stable share `rate` of keys, chosen
+ * by a hash of the seed and the key, so the same response is always in or
+ * always out, two responses are drawn independently even when their keys
+ * differ by one character, and changing the seed draws a new sample.
+ */
+declare function inAuditSample(key: string, rate: number, seed: string): boolean;
+/**
+ * Where a model's grade goes: to count, or to a person first. Deterministic —
+ * the same grade, context and policy always route the same way — and the
+ * decision says every reason it rests on, in {@link GradeRoutingReason}'s
+ * order, so an appeal can see why a person did or did not mark a response.
+ *
+ * - **In `exam`, a grade needs a calibration of its exact configuration**
+ *   (`no-calibration`): the model and prompt its `grader` names, and the
+ *   item's rubric and target. Fail closed: without a matching report, every
+ *   grade goes to a person.
+ * - A supplied report must meet the policy's thresholds (`calibration-below-policy`).
+ * - A criterion on levels the grader was less sure of than
+ *   `minLevelProbability`, or showed no probabilities for (`unsure`), a
+ *   grader that asked for review (`model-asked`), a `low` confidence where
+ *   the policy routes on it (`low-confidence`), and the audit sample
+ *   (`audit-sample`) send it to a person too.
+ *
+ * A mode other than `exam` or `practice`, a policy threshold that is not a
+ * finite number, a rate outside 0 to 1, or an audit without a `sampleKey`
+ * throws a `RangeError`: it is the caller's configuration, not the grade's,
+ * and a typo must not quietly make an exam a practice.
+ */
+declare function routeGrade(grade: GradeRecord, context: GradeRoutingContext): GradeRouting;
+/**
+ * The outcome a routed grade gives its slot. To the model: the grade, with the
+ * decision on its `routing`, lifted as `outcomeFromGrade` lifts any grade. To a
+ * person: `{ status: 'deferred', reason: 'awaiting_human_review', pendingGrade }`
+ * — not `graded`, so its `passed` is never read as a verdict, and a composed
+ * attempt stays `provisional` until a person's grade replaces it.
+ */
+declare function outcomeFromRoutedGrade(grade: GradeRecord, routing: GradeRouting): ItemOutcome;
+//#endregion
 //#region src/scoring/dictation/align.d.ts
 /** One transcript word, or one extra word the learner typed, after alignment. */
 interface DictationWordAlignment {
@@ -1067,5 +1391,5 @@ interface ItemTriesOutcome {
  */
 declare function evaluateTries(data: ActivityData, responses: readonly LearnerResponse[], options?: EvaluateOptions): ItemTriesOutcome;
 //#endregion
-export { SpeechAssessment as $, diffDictationChars as A, ItemTry as B, validateItemScoringPolicy as C, DICTATION_MAX_TEXT_LENGTH as D, DICTATION_MAX_EQUIVALENCE_LENGTH as E, dictationReferenceWords as F, CompositionPolicy as G, ResolvedItemScoringPolicy as H, ItemScoringCount as I, SectionScore as J, PassFailureReason as K, ItemScoringPolicy as L, DictationReference as M, DictationWordAlignment as N, DICTATION_MAX_TRANSCRIPT_LENGTH as O, alignDictation as P, ReadAloudWordState as Q, ItemScoringPolicyIssue as R, scoreTries as S, DICTATION_MAX_EQUIVALENCES as T, AssessmentScore as U, ItemTryScore as V, AssessmentSectionInput as W, GradeReadAloudOptions as X, composeAssessmentScore as Y, ReadAloudWordAlignment as Z, DEFAULT_PASS_THRESHOLD as _, evaluateTries as a, SpeechUnscorable as at, ITEM_SCORING_MAX_RETRIES as b, inspectWav as c, SpeechWordError as ct, READ_ALOUD_MAX_SECONDS as d, Band as dt, SpeechMeasurement as et, READ_ALOUD_MAX_TAKES as f, RoundingMode as ft, alignReadAloud as g, roundGrade as gt, validateSpeechAssessment as h, gte as ht, evaluate as i, SpeechSyllable as it, DictationAlignment as j, DictationCharOp as k, READ_ALOUD_MAX_DIMENSION_WEIGHT as l, WavInspection as lt, gradeReadAloud as m, classifyBand as mt, ItemTriesOutcome as n, SpeechPhonemeCandidate as nt, score as o, SpeechUnscorableCode as ot, SPEECH_ASSESSMENT_MAX_WORDS as p, RoundingPolicy as pt, ScoredItem as q, ScoringOptions as r, SpeechPlausibilityPolicy as rt, outcomeFromUnscorable as s, SpeechWord as st, EvaluateOptions as t, SpeechPhoneme as tt, READ_ALOUD_MAX_REFERENCE_LENGTH as u, WavInspectionPolicy as ut, computePassThreshold as v, DICTATION_MAX_ACCEPTED_TRANSCRIPTS as w, resolveItemScoringPolicy as x, DEFAULT_ITEM_SCORING_POLICY as y, ItemTriesScore as z };
-//# sourceMappingURL=index-CVWvymVb.d.ts.map
+export { hasGrade as $, diffDictationChars as A, Band as At, outcomeFromRoutedGrade as B, validateItemScoringPolicy as C, SpeechSyllable as Ct, DICTATION_MAX_TEXT_LENGTH as D, SpeechWordError as Dt, DICTATION_MAX_EQUIVALENCE_LENGTH as E, SpeechWord as Et, dictationReferenceWords as F, roundGrade as Ft, CalibrationReport as G, GradeFromJudgementOptions as H, CalibrationThresholds as I, TotalCalibration as J, CalibrationScope as K, GradeRoutingContext as L, DictationReference as M, RoundingPolicy as Mt, DictationWordAlignment as N, classifyBand as Nt, DICTATION_MAX_TRANSCRIPT_LENGTH as O, WavInspection as Ot, alignDictation as P, gte as Pt, gradeFromRubric as Q, GradeRoutingPolicy as R, scoreTries as S, SpeechPlausibilityPolicy as St, DICTATION_MAX_EQUIVALENCES as T, SpeechUnscorableCode as Tt, gradeFromJudgement as U, routeGrade as V, CalibrationPair as W, graderConfiguration as X, calibrationReport as Y, GradeFromRubricOptions as Z, DEFAULT_PASS_THRESHOLD as _, ReadAloudWordState as _t, evaluateTries as a, ItemTry as at, ITEM_SCORING_MAX_RETRIES as b, SpeechPhoneme as bt, inspectWav as c, AssessmentScore as ct, READ_ALOUD_MAX_SECONDS as d, PassFailureReason as dt, outcomeFromGrade as et, READ_ALOUD_MAX_TAKES as f, ScoredItem as ft, alignReadAloud as g, ReadAloudWordAlignment as gt, validateSpeechAssessment as h, GradeReadAloudOptions as ht, evaluate as i, ItemTriesScore as it, DictationAlignment as j, RoundingMode as jt, DictationCharOp as k, WavInspectionPolicy as kt, READ_ALOUD_MAX_DIMENSION_WEIGHT as l, AssessmentSectionInput as lt, gradeReadAloud as m, composeAssessmentScore as mt, ItemTriesOutcome as n, ItemScoringPolicy as nt, score as o, ItemTryScore as ot, SPEECH_ASSESSMENT_MAX_WORDS as p, SectionScore as pt, CriterionCalibration as q, ScoringOptions as r, ItemScoringPolicyIssue as rt, outcomeFromUnscorable as s, ResolvedItemScoringPolicy as st, EvaluateOptions as t, ItemScoringCount as tt, READ_ALOUD_MAX_REFERENCE_LENGTH as u, CompositionPolicy as ut, computePassThreshold as v, SpeechAssessment as vt, DICTATION_MAX_ACCEPTED_TRANSCRIPTS as w, SpeechUnscorable as wt, resolveItemScoringPolicy as x, SpeechPhonemeCandidate as xt, DEFAULT_ITEM_SCORING_POLICY as y, SpeechMeasurement as yt, inAuditSample as z };
+//# sourceMappingURL=index-DeD8EI1D.d.ts.map

package/dist/index-DeD8EI1D.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index-DeD8EI1D.d.ts","names":[],"sources":["../src/scoring/rounding.ts","../src/types/speech.ts","../src/scoring/compose.ts","../src/types/item-scoring.ts","../src/grading.ts","../src/scoring/assisted/calibration.ts","../src/scoring/assisted/grade-from-judgement.ts","../src/scoring/assisted/routing.ts","../src/scoring/dictation/align.ts","../src/scoring/dictation/chars.ts","../src/scoring/dictation/normalize.ts","../src/scoring/item-scoring.ts","../src/scoring/pass-threshold.ts","../src/scoring/speech/align.ts","../src/scoring/speech/assessment.ts","../src/scoring/speech/grade.ts","../src/scoring/speech/limits.ts","../src/scoring/speech/wav.ts","../src/scoring/unscorable.ts","../src/scoring/index.ts"],"mappings":"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"}

package/dist/{index-CcHDTxIZ.d.ts → index-Dj92T76o.d.ts}

@@ -1,4 +1,4 @@
-import { Sn as XAPIStatement, bn as XAPIResult, gn as XAPIContext, mn as XAPIActor, sn as ScoringResult } from "./ai-CnmLPMzd.js";
+import { An as XAPIStatement, On as XAPIResult, Sn as XAPIActor, pn as ScoringResult, wn as XAPIContext } from "./ai-i3jwXnpX.js";
 //#region src/xapi/verbs.d.ts
 /**
  * The set of xAPI verbs emitted by SDK activities, keyed by a stable
@@ -150,4 +150,4 @@ declare function xapiDefinitionFor(data: {
 declare function validateXAPIStatement(statement: XAPIStatement): void;
 //#endregion
 export { XAPIObjectParams as a, xapiDefinitionFor as c, XAPI_VERB_DISPLAY as d, SubmittedStatementParams as i, XAPIVerb as l, AnsweredStatementParams as n, XAPIStatementParams as o, CompletedStatementParams as r, xAPIBuilder as s, validateXAPIStatement as t, XAPIVerbKey as u };
-//# sourceMappingURL=index-CcHDTxIZ.d.ts.map
+//# sourceMappingURL=index-Dj92T76o.d.ts.map

package/dist/{index-CcHDTxIZ.d.ts.map → index-Dj92T76o.d.ts.map}

@@ -1 +1 @@
-{"version":3,"file":"index-CcHDTxIZ.d.ts","names":[],"sources":["../src/xapi/verbs.ts","../src/xapi/builder.ts","../src/xapi/validators.ts"],"mappings":";;;;;;cAIa;;;;;;;;;;;;;;;;;;;;;;;;;;KA2BD,2BAA2B;;;;;cAM1B,mBAAmB,OAAO,aAAa;;;;UCxBnC;;EAEf;EACA,OAAO;EACP,cAAc;;EAEd;;EAEA;;EAEA;;EAEA,UAAU;IAAQ;IAAY,cAAc;;;;UAI7B;EACf,OAAO;EACP,MAAM;EACN,QAAQ;EACR,SAAS;EACT,UAAU;;;UAIK;EACf,OAAO;EACP,QAAQ;EACR,eAAe;EACf;;EAEA;EACA,UAAU;EACV,mBAAmB;;;;;;;UAQJ;EACf,OAAO;EACP,QAAQ;EACR;;EAEA;EACA,UAAU;EACV,mBAAmB;;;UAIJ;EACf,OAAO;EACP,QAAQ;EACR,gBAAgB;EAChB;EACA,UAAU;EACV,mBAAmB;;;;;;;cAiGR;EACY,eAAA,QAAA,sBAAsB;EAoBd,uBAAA,QAAA,0BAA0B;;;;;;;EAqBzB,wBAAA,QAAA,2BAA2B;EAc3B,wBAAA,QAAA,2BAA2B;;;;;;;;;;;;;;;;iBA8B7C,kBAAkB;EAAQ;IAAiB,QAAQ;;;;;;;;;;;;;;;;iBClHnD,sBAAsB,WAAW"}
+{"version":3,"file":"index-Dj92T76o.d.ts","names":[],"sources":["../src/xapi/verbs.ts","../src/xapi/builder.ts","../src/xapi/validators.ts"],"mappings":";;;;;;cAIa;;;;;;;;;;;;;;;;;;;;;;;;;;KA2BD,2BAA2B;;;;;cAM1B,mBAAmB,OAAO,aAAa;;;;UCxBnC;;EAEf;EACA,OAAO;EACP,cAAc;;EAEd;;EAEA;;EAEA;;EAEA,UAAU;IAAQ;IAAY,cAAc;;;;UAI7B;EACf,OAAO;EACP,MAAM;EACN,QAAQ;EACR,SAAS;EACT,UAAU;;;UAIK;EACf,OAAO;EACP,QAAQ;EACR,eAAe;EACf;;EAEA;EACA,UAAU;EACV,mBAAmB;;;;;;;UAQJ;EACf,OAAO;EACP,QAAQ;EACR;;EAEA;EACA,UAAU;EACV,mBAAmB;;;UAIJ;EACf,OAAO;EACP,QAAQ;EACR,gBAAgB;EAChB;EACA,UAAU;EACV,mBAAmB;;;;;;;cAiGR;EACY,eAAA,QAAA,sBAAsB;EAoBd,uBAAA,QAAA,0BAA0B;;;;;;;EAqBzB,wBAAA,QAAA,2BAA2B;EAc3B,wBAAA,QAAA,2BAA2B;;;;;;;;;;;;;;;;iBA8B7C,kBAAkB;EAAQ;IAAiB,QAAQ;;;;;;;;;;;;;;;;iBClHnD,sBAAsB,WAAW"}