@intellectif/lk-core 1.2.0 → 1.4.0

package/dist/index-BAfEHCnD.d.cts

@@ -0,0 +1,1071 @@
+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.cjs";
+//#region src/scoring/rounding.d.ts
+/**
+ * Rounding for assessment scores.
+ *
+ * Rounding is **two different operations** that must not share one policy, and
+ * conflating them silently inverts one of them:
+ *
+ * - **Grade rounding** decides the number a learner is shown and recorded
+ *   against. It rounds to a fixed number of decimal places, conventionally
+ *   half-up, so a learner shown "70%" is not recorded as a fail at 69.6.
+ * - **Band / level classification** decides which level someone is placed in.
+ *   It deliberately **floors**: placing a learner above their real level is
+ *   the more harmful error, so a band boundary must not be reached by
+ *   rounding up.
+ *
+ * There is therefore no default `RoundingPolicy` anywhere in this SDK, and
+ * `dp` has no default either — an integrator's deliberate choice must never be
+ * supplied by us.
+ */
+/** How a value is rounded to `dp` decimal places. */
+type RoundingMode = 'half-up' | 'half-even' | 'floor' | 'ceil';
+/** A rounding policy. Both fields are required — the SDK never guesses either. */
+interface RoundingPolicy {
+  mode: RoundingMode;
+  /** Decimal places. Load-bearing: `dp: 2` is what stops 69.6 becoming a fail at 70. */
+  dp: number;
+}
+/**
+ * Rounds `value` to `policy.dp` places under `policy.mode`.
+ *
+ * Idempotent for every mode: rounding an already-rounded value returns it
+ * unchanged. That matters because a composed score is rounded once and then
+ * compared through {@link gte}, which rounds again.
+ */
+declare function roundGrade(value: number, policy: RoundingPolicy): number;
+/**
+ * Threshold comparison that rounds **both sides** before comparing.
+ *
+ * Comparing a raw float against a rounded threshold is how a learner ends up
+ * shown one number and recorded against another. Rounding both sides — and
+ * allowing an epsilon — makes "what the learner sees" and "what the gradebook
+ * decides" the same comparison.
+ */
+declare function gte(value: number, threshold: number, policy: RoundingPolicy): boolean;
+/** A named band with an inclusive lower bound, e.g. `{ name: 'B1', min: 0.6 }`. */
+interface Band {
+  name: string;
+  /** Inclusive lower bound on the same scale as the value being classified. */
+  min: number;
+}
+/**
+ * Classifies a value into a band by **flooring**: the highest band whose `min`
+ * the value actually reaches. Deliberately does NOT round up to a boundary —
+ * over-placement is the more harmful error, so a learner just below a boundary
+ * stays below it.
+ *
+ * Returns `null` when the value reaches no band's minimum.
+ */
+declare function classifyBand(value: number, bands: readonly Band[]): Band | null;
+//#endregion
+//#region src/types/speech.d.ts
+/**
+ * How the assessor classified a word against the reference text: `none`, read
+ * as written; `mispronunciation`, read but not well enough; `omission`, in the
+ * reference but not heard; `insertion`, heard but not in the reference.
+ */
+type SpeechWordError = 'none' | 'mispronunciation' | 'omission' | 'insertion';
+/** A phoneme the assessor heard instead of the expected one, and its score. */
+interface SpeechPhonemeCandidate {
+  /** The phoneme, in the assessment's `phonemeAlphabet`. */
+  symbol: string;
+  /** 0..100. */
+  score: number;
+}
+/** One phoneme of a word, as the assessor measured it. Assessors report different subsets. */
+interface SpeechPhoneme {
+  /** The phoneme, in the assessment's `phonemeAlphabet`. Absent when the assessor does not name it. */
+  symbol?: string;
+  /** 0..100. Absent means not assessed, never 0. */
+  accuracy?: number;
+  /** Milliseconds from the start of the recording. */
+  startMs?: number;
+  /** Milliseconds. */
+  durationMs?: number;
+  /** The phonemes the assessor heard instead, in the order it reported them. */
+  heardAs?: SpeechPhonemeCandidate[];
+}
+/** One syllable of a word, as the assessor measured it. */
+interface SpeechSyllable {
+  /** The syllable as the assessor reports it. */
+  text: string;
+  /** The letters of the word the syllable is written with, when the assessor reports them. */
+  grapheme?: string;
+  /** 0..100. Absent means not assessed, never 0. */
+  accuracy?: number;
+  /** Milliseconds from the start of the recording. */
+  startMs?: number;
+  /** Milliseconds. */
+  durationMs?: number;
+}
+/** One word of a {@link SpeechAssessment}. */
+interface SpeechWord {
+  /** The word as the assessor reports it. */
+  text: string;
+  /** 0..100. Absent means not assessed — never read as 0. */
+  accuracy?: number;
+  /** The assessor's classification of the word. */
+  error: SpeechWordError;
+  /** The provider's own error label, verbatim, for audit. No grade reads it. */
+  vendorError?: string;
+  /** Milliseconds from the start of the recording. */
+  startMs?: number;
+  /** Milliseconds. */
+  durationMs?: number;
+  syllables?: SpeechSyllable[];
+  phonemes?: SpeechPhoneme[];
+  /**
+   * Confidences (0..1) that an unexpected pause came before the word, or that
+   * an expected one is missing. Display only: no grade reads them.
+   */
+  breaks?: {
+    unexpected?: number;
+    missing?: number;
+  };
+}
+/**
+ * A pronunciation assessor's result, in the SDK's neutral shape. Every score in
+ * it is on a 0..100 scale. Check one with `validateSpeechAssessment`.
+ */
+interface SpeechAssessment {
+  assessmentVersion: '1.0';
+  /** `no_speech`: the assessor heard nothing to assess — which is never a score of 0. */
+  status: 'assessed' | 'no_speech';
+  /** `scripted`: measured against a known text. Only a scripted assessment grades a read-aloud item. */
+  task: 'scripted' | 'unscripted';
+  /** The locale the assessment was made for: canonical, with a region — the rule `ReadAloudData.locale` follows. */
+  locale: string;
+  /**
+   * The text the assessment was made against: the authored reference text,
+   * verbatim. Required when scripted, so a grade can refuse evidence made
+   * against another text.
+   */
+  referenceText?: string;
+  /**
+   * The `RecordingRef.key` of the recording that was assessed. Required when
+   * scripted, so a grade can refuse evidence made for another recording.
+   */
+  recordingKey?: string;
+  /** Who measured. Evidence from `'ai'` grades only when the caller opts in. */
+  assessor: Grader;
+  /** What every score is out of. Stated, so an adapter never leaves it to be assumed. */
+  scale: 100;
+  /** Utterance-level scores, 0..100. An absent score was not assessed; it is never read as 0. */
+  scores: {
+    accuracy?: number;
+    fluency?: number;
+    completeness?: number;
+    prosody?: number;
+    overall?: number;
+  };
+  /** What the assessor recognised, as text. */
+  recognizedText?: string;
+  /**
+   * Who judged omissions, insertions and mispronunciations. `assessor`: the
+   * assessor did, and its word `error` labels are trusted. `none`: it did not,
+   * so a heard word that differs from its reference word is marked
+   * mispronounced.
+   */
+  miscue: 'assessor' | 'none';
+  /** The alphabet phoneme symbols are written in. Required whenever a phoneme names a `symbol` or `heardAs`. */
+  phonemeAlphabet?: 'ipa' | 'sapi';
+  /** The words, in the order the assessor reported them. */
+  words: SpeechWord[];
+  /** Utterance-level prosody: `monotoneConfidence` is 0..1, display only. */
+  prosody?: {
+    monotoneConfidence?: number;
+  };
+  /** Recording quality. Informational only: no grade reads it. */
+  signal?: {
+    snrDb?: number;
+  };
+}
+/**
+ * The server's own measurement of a recording, from `inspectWav`. It is what
+ * decides whether a take is plausible speech; a duration the client reported
+ * never is.
+ */
+interface SpeechMeasurement {
+  /** Length of the recording, in milliseconds. */
+  durationMs: number;
+  /** Milliseconds of the recording at or above the silence floor. At most `durationMs`. */
+  voicedMs: number;
+}
+/**
+ * When a take is too little speech to grade. Both fields are required: the SDK
+ * holds no default for either, because each is a decision about an
+ * application's learners and its assessor.
+ */
+interface SpeechPlausibilityPolicy {
+  /** The most words per second of voiced time a genuine reading can reach. Finite and above 0. */
+  maxWordsPerSecond: number;
+  /** The least voiced time, in milliseconds, a gradable take contains. Finite and at least 0. */
+  minVoicedMs: number;
+}
+/**
+ * Why a read-aloud take cannot be graded:
+ * - `invalid_assessment` — the assessment fails `validateSpeechAssessment`;
+ * - `task_mismatch` — it is not a scripted assessment;
+ * - `locale_mismatch` — it was made for another locale than the item's;
+ * - `reference_mismatch` — it was made against another text than the item's;
+ * - `recording_mismatch` — it was made for another recording than the response's;
+ * - `assessor_not_accepted` — its assessor is `'ai'`, and the caller did not opt in;
+ * - `no_speech` — the assessor heard no speech;
+ * - `insufficient_voiced_time` — the recording holds less voiced time than the policy requires;
+ * - `implausible_speech_rate` — more words were recognised than the voiced time can hold;
+ * - `missing_dimension` — a weighted dimension has no score in the assessment.
+ */
+type SpeechUnscorableCode = 'invalid_assessment' | 'task_mismatch' | 'locale_mismatch' | 'reference_mismatch' | 'recording_mismatch' | 'assessor_not_accepted' | 'no_speech' | 'insufficient_voiced_time' | 'implausible_speech_rate' | 'missing_dimension';
+/** A read-aloud take that cannot be graded. Never a zero: see `outcomeFromUnscorable`. */
+interface SpeechUnscorable {
+  unscorable: true;
+  /** Machine-readable. See {@link SpeechUnscorableCode}. */
+  code: SpeechUnscorableCode;
+  /** A developer-facing English sentence. */
+  reason: string;
+}
+/**
+ * Options for `gradeReadAloud`. The plausibility policy is required: the SDK
+ * holds no default for a threshold that decides whether a take is graded.
+ */
+interface GradeReadAloudOptions {
+  /** The server's measurement of the recording (inspectWav). `null` only for a blank response. */
+  measured: SpeechMeasurement | null;
+  /** When a take is too little speech to grade. */
+  plausibility: SpeechPlausibilityPolicy;
+  /** Accept `assessor.kind: 'ai'` evidence. Off unless set. */
+  allowAiAssessor?: boolean;
+  /** Compare the pass line with both sides rounded, as `gradeFromRubric` does. The score stays unrounded. */
+  rounding?: RoundingPolicy;
+}
+/** How a word of a read-aloud attempt is marked. */
+type ReadAloudWordState = 'correct' | 'mispronounced' | 'omitted' | 'inserted';
+/**
+ * One entry of `alignReadAloud`: a reference word and what was heard for it,
+ * or a heard word that is not in the reference.
+ */
+interface ReadAloudWordAlignment {
+  /** `w<n>` for a reference word, as `dictationReferenceWords` numbers them; absent for an `inserted` word. */
+  itemId?: string;
+  /** The normalised reference word; `''` for an `inserted` word. */
+  reference: string;
+  /**
+   * The normalised heard word: `''` for an `omitted` word, and also for an
+   * `inserted` word whose text normalises to nothing — an assessor can tag a
+   * dash as an insertion, and every insertion gets an entry. Branch on `state`,
+   * never on the empty string.
+   */
+  heard: string;
+  state: ReadAloudWordState;
+  /** The assessor word's accuracy (0..100), when it has one. */
+  accuracy?: number;
+  /** Index into `assessment.words` of the word this entry came from. */
+  wordIndex?: number;
+}
+/**
+ * What `inspectWav` found in a recording's bytes: the duration, format, peak
+ * level and voiced time of a 16-bit PCM WAV, or why it could not read one.
+ */
+type WavInspection = {
+  valid: true;
+  /** Length of the audio, in milliseconds. */
+  durationMs: number;
+  sampleRate: number;
+  channels: number;
+  bitsPerSample: 16;
+  /** The loudest sample across every channel, in dBFS; `-Infinity` for digital silence or no samples. */
+  peakDbfs: number;
+  /** Milliseconds of the windows at or above the policy's silence floor. */
+  voicedMs: number;
+} | {
+  valid: false;
+  reason: 'not_wav' | 'unsupported_encoding' | 'truncated';
+};
+/** How `inspectWav` decides which parts of a recording are voiced. Both fields are required. */
+interface WavInspectionPolicy {
+  /** A window whose RMS level is at or above this many dBFS is voiced. Finite, and at most 0. */
+  silenceDbfs: number;
+  /** The window length, in milliseconds. Finite, and above 0. */
+  frameMs: number;
+}
+//#endregion
+//#region src/scoring/compose.d.ts
+/**
+ * Sectioned assessment scoring — weights, per-section thresholds, and an
+ * explicit reason when an attempt fails.
+ *
+ * This exists because the formula is invariably implemented twice: once on the
+ * server that records the grade, and again on the client that shows a learner
+ * their grade breakdown. Two implementations of one formula is exactly the
+ * duplication an SDK should remove, and they drift — usually in the scale
+ * (0–1 vs 0–100) or in whether a section override is honoured.
+ */
+/** One item's contribution to a section. */
+interface ScoredItem {
+  /**
+   * Identity of the SLOT, not the activity. The same activity can legitimately
+   * appear in two sections; keying on the activity id collapses them into one
+   * and silently scores the second occurrence as zero.
+   */
+  slotId: string;
+  /** The activity that filled this slot, for reporting. */
+  activityId?: string;
+  /** Maximum points this slot is worth. */
+  points: number;
+  /** What the learner achieved, or why there is no grade yet. */
+  outcome: ItemOutcome;
+}
+/** A weighted section of an assessment. */
+interface AssessmentSectionInput {
+  id: string;
+  title?: string;
+  /** Relative weight. Weights are normalised by their sum, so they need not total 1. */
+  weight: number;
+  /** Overrides the assessment-wide section threshold for this section only. */
+  passThresholdOverride?: number;
+  items: ScoredItem[];
+}
+/** Policy for {@link composeAssessmentScore}. */
+interface CompositionPolicy {
+  /** Scaled [0,1] overall score required to pass. */
+  passThreshold: number;
+  /** Scaled [0,1] score each section must reach, when sections gate the pass. */
+  sectionThreshold?: number;
+  /**
+   * How grades are rounded. Required, with no default: see `RoundingPolicy` —
+   * grade rounding and band classification are different operations and the
+   * SDK must not choose either for you.
+   */
+  rounding: RoundingPolicy;
+}
+/** Per-section result. */
+interface SectionScore {
+  id: string;
+  title?: string;
+  /** The authored weight, verbatim. */
+  weight: number;
+  /**
+   * The weight ACTUALLY used in the total, so a client can rebuild the grade
+   * from `sections[]` and agree with the record:
+   *
+   * ```ts
+   * roundGrade(
+   *   sections.reduce((sum, s) => sum + s.score * s.normalizedWeight, 0),
+   *   policy.rounding,
+   * ) === result.score            // exact, by construction
+   * ```
+   *
+   * Apply the same final rounding: the raw weighted sum of already-rounded
+   * section scores is not itself a rounded value (0.85 and 1.00 at equal
+   * weights sum to 0.925 against a recorded 0.93), so comparing it unrounded
+   * is off by up to half a quantum.
+   *
+   * Sections with nothing graded carry `0` here, because they contribute
+   * nothing; the remaining weights are renormalised among themselves.
+   */
+  normalizedWeight: number;
+  earnedPoints: number;
+  /** Points that are currently gradable — excludes items still awaiting a grade. */
+  gradedMaxPoints: number;
+  /** Every point in the section, whether graded yet or not. */
+  maxPoints: number;
+  /** Scaled [0,1] over the GRADED points, rounded once. */
+  score: number;
+  passed: boolean;
+  /** Threshold this section was judged against, after any override. */
+  appliedThreshold: number | null;
+  /**
+   * Slots still awaiting a grade — including any in {@link rejectedSlotIds},
+   * whose grade came back unusable and is still owed.
+   */
+  pendingSlotIds: string[];
+  /** See {@link AssessmentScore.rejectedSlotIds}; this section's share of them. */
+  rejectedSlotIds?: string[];
+  /** Slots that can never be graded, excluded from the denominator. */
+  unscorableSlotIds: string[];
+}
+/** Why an attempt failed, or `null` when it passed. */
+type PassFailureReason = 'overall_below_threshold' | 'section_below_threshold' | 'both' | null;
+/** Result of composing an assessment. */
+interface AssessmentScore {
+  sections: SectionScore[];
+  /** Weighted total, scaled [0,1], rounded once. */
+  score: number;
+  /**
+   * Whether the attempt passed — `null` while `status` is `provisional`,
+   * because an attempt with work still ungraded has not passed OR failed yet.
+   * Returning `false` there would let a UI keyed on `passed` show a fail for
+   * an essay nobody has marked.
+   */
+  passed: boolean | null;
+  /** `null` while provisional, for the same reason as {@link passed}. */
+  passFailureReason: PassFailureReason;
+  /**
+   * `provisional` while any item is still awaiting a grade — the total is
+   * computed over what HAS been graded, so it can still move. Do not record a
+   * provisional score as final. Items that can NEVER be graded
+   * (`unscorableSlotIds`) do not hold the result provisional; items whose
+   * grade was rejected (`rejectedSlotIds`) do.
+   */
+  status: 'final' | 'provisional';
+  /**
+   * Slots still awaiting a grade, excluded from the denominator. `status` is
+   * `provisional` exactly when this is not empty. Includes every slot in
+   * {@link rejectedSlotIds}.
+   */
+  pendingSlotIds: string[];
+  /**
+   * Slots whose outcome claimed a grade that cannot be one: a `score` or
+   * `maxScore` that is not a finite number, a `maxScore` of 0 or less, or a
+   * score below 0 or above its `maxScore` (beyond float noise of one part in a
+   * billion) — and deferred outcomes `outcomeFromGrade` returned for such a
+   * record (`reason: 'grade_rejected'`). Each is also in
+   * {@link pendingSlotIds}: its real grade is still owed, so it holds the
+   * result `provisional` with `passed: null` rather than being counted (NaN or
+   * 4300% on the record) or dropped (a failing grade vanishing into a final
+   * pass). Re-grade these slots; waiting will not fix them.
+   *
+   * Present only when at least one slot was rejected, so a result without one
+   * is exactly what earlier versions returned.
+   */
+  rejectedSlotIds?: string[];
+  /** Slots that can never be graded. Excluded from the denominator. */
+  unscorableSlotIds: string[];
+}
+/**
+ * Composes per-item outcomes into a sectioned assessment score.
+ *
+ * Weights are normalised by their sum. Each section's score is computed over
+ * the points that are actually gradable and rounded ONCE, before any threshold
+ * comparison, so the number a learner is shown is the number that decides the
+ * outcome. Items still awaiting a grade are excluded from the denominator
+ * rather than counted as zero, and the result is reported as `provisional`
+ * until every item has a grade. An outcome whose score cannot be a grade out of
+ * its `maxScore` is not a grade either: it is held the same way and named in
+ * `rejectedSlotIds`.
+ */
+declare function composeAssessmentScore(sections: readonly AssessmentSectionInput[], policy: CompositionPolicy): AssessmentScore;
+//#endregion
+//#region src/types/item-scoring.d.ts
+/**
+ * How the questions on a paper are scored when a learner can try again or ask
+ * for hints: how many tries there are, which one counts, and what each try and
+ * each hint costs.
+ *
+ * It sits beside the {@link DeliveryPolicy} and is set per paper in the same
+ * way, but it is a separate object for a reason: every delivery setting takes
+ * something away from what a learner is shown and cannot move a grade, while
+ * every setting here moves one. A delivery policy can be read charitably; this
+ * one cannot, because a grade-moving setting has no safe direction to read a
+ * mistake in. {@link resolveItemScoringPolicy} throws on one.
+ *
+ * Every setting is optional, and absent or `null` is its default. The defaults
+ * are exactly how questions were scored before this policy existed: one try,
+ * nothing costs anything, and the first (only) try counts.
+ *
+ * **The SDK's components apply it in `practice`**, where they grade. An exam's
+ * hints stay free and uncounted, as they always were. See
+ * https://github.com/intellectif/learning-kit/blob/main/docs/scoring.md
+ *
+ * @see {@link scoreTries} for the arithmetic.
+ */
+interface ItemScoringPolicy {
+  /**
+   * What each hint costs, as a fraction of the question's marks: `0.1` takes
+   * a tenth of them per hint. A hint is any a learner is shown before
+   * answering — an author's hint on a blank, a dictation's hint word, an AI
+   * hint — and is counted in the response's `hintsRevealed`.
+   *
+   * A number from 0 to 1. Default 0.
+   */
+  hintPenalty?: number | null;
+  /**
+   * How many more tries a learner gets after an answer that did not earn full
+   * marks: "Try again". A whole number from 0 to 10. Default 0 — one try, as
+   * before.
+   */
+  retries?: number | null;
+  /**
+   * What each try after the first costs, as a fraction of the question's
+   * marks: with `0.25`, a right answer on the second try earns 75%. A number
+   * from 0 to 1. Default 0.
+   *
+   * It applies only where a later try can count — `counts: 'best'` or
+   * `'last'` — and {@link validateItemScoringPolicy} refuses it otherwise.
+   */
+  retryPenalty?: number | null;
+  /**
+   * Which try's score is the question's score.
+   *
+   * - `first` (default): the first. Tries after it are for learning, and
+   *   change no grade — which is why it is the default: switching tries on
+   *   moves no grade until a school also chooses one of the others.
+   * - `best`: the highest, after what each try cost. Never goes down.
+   * - `last`: the latest the policy allows.
+   */
+  counts?: ItemScoringCount | null;
+}
+/** Which try counts: see {@link ItemScoringPolicy.counts}. */
+type ItemScoringCount = 'first' | 'best' | 'last';
+/**
+ * A policy with every setting spelled out: what
+ * {@link resolveItemScoringPolicy} returns and what an attempt plan records,
+ * so the record never depends on a default that may one day change.
+ */
+interface ResolvedItemScoringPolicy {
+  hintPenalty: number;
+  retries: number;
+  retryPenalty: number;
+  counts: ItemScoringCount;
+}
+/** One thing {@link validateItemScoringPolicy} found wrong with a policy. */
+interface ItemScoringPolicyIssue {
+  /** The setting, e.g. `hintPenalty`, or `''` for the policy itself. */
+  path: string;
+  message: string;
+}
+/** One graded try at a question, as {@link scoreTries} reads it. */
+interface ItemTry {
+  /** What the try's answer scored, before anything it cost: from `score()`. */
+  score: number;
+  maxScore: number;
+  /**
+   * Hints shown before this try was submitted, counted from the start of the
+   * question — so a later try's count includes an earlier one's. The response's
+   * `hintsRevealed`. Anything but a whole number of 0 or more reads as 0.
+   */
+  hintsRevealed?: number | undefined;
+}
+/** One try, as {@link scoreTries} scored it. */
+interface ItemTryScore {
+  /** What the answer scored, before anything it cost. */
+  score: number;
+  /** What it scored after what it cost, never below 0. */
+  scored: number;
+  maxScore: number;
+  /** The hints it was charged for. */
+  hintsRevealed: number;
+  /** What it cost, as a fraction of `maxScore`: hints, and the tries before it. */
+  penalty: number;
+}
+/** A question's score under a policy, from its tries. */
+interface ItemTriesScore {
+  /** The counted try's score after what it cost, never below 0. */
+  score: number;
+  maxScore: number;
+  /** 0-based: the try whose score counts. */
+  counted: number;
+  /**
+   * Every try the policy allows, in order, as scored. A try past the
+   * allowance (`1 + retries`) is left out: a learner cannot be given one, so a
+   * record that holds one is not believed.
+   */
+  tries: ItemTryScore[];
+}
+//#endregion
+//#region src/scoring/dictation/align.d.ts
+/** One transcript word, or one extra word the learner typed, after alignment. */
+interface DictationWordAlignment {
+  /** `w<n>`, the 1-based position of a transcript word; absent for an extra word. */
+  itemId?: string;
+  /** The transcript word, normalised; `''` for an extra word. */
+  reference: string;
+  /** The word the learner typed for it, normalised; `''` for a missing word. */
+  attempt: string;
+  /** How alike the two words are, in [0, 1]; `0` for a missing or an extra word. */
+  similarity: number;
+  status: 'correct' | 'incorrect' | 'missing' | 'extra';
+}
+/**
+ * The comparison a dictation grade is made of: the normalised strings, which
+ * candidate transcript the attempt was scored against, and the word pairings.
+ * The same data the scorer reads, so a marked display and the grade cannot
+ * disagree.
+ */
+interface DictationAlignment {
+  /**
+   * Which candidate the attempt was scored against, by ORIGINAL position:
+   * `0` is `transcript`, `n` is `acceptedTranscripts[n − 1]`; `-1` when no
+   * candidate survives normalisation (stale or transcript-less data).
+   */
+  candidateIndex: number;
+  /** The chosen candidate, normalised; `''` when `candidateIndex` is `-1`. */
+  reference: string;
+  /** The attempt, normalised and possibly truncated. */
+  attempt: string;
+  /**
+   * Whether the learner's text was cut: at `DICTATION_MAX_TEXT_LENGTH` before or
+   * after normalisation, or while equivalence rules were growing it.
+   */
+  truncated: boolean;
+  /** The similarity of `attempt` to `reference` — the score. */
+  similarity: number;
+  /** Transcript words and extra words, in the order they align. */
+  words: DictationWordAlignment[];
+}
+/**
+ * What `alignDictation` reads. Every field optional, and read defensively: full
+ * data, a practice payload, a `redact(data, { reveal: 'after-submit' })`
+ * projection, or a plain redacted projection with no transcript at all — which
+ * yields `candidateIndex: -1`, never a throw.
+ */
+type DictationReference = Partial<Pick<DictationData, 'transcript' | 'acceptedTranscripts' | 'tolerance'>>;
+/**
+ * The words the scorer can emit a detail for, one list per candidate — index 0
+ * is the transcript, index n is `acceptedTranscripts[n − 1]` — each word in the
+ * normalised form `correctResponse` carries. A candidate that normalises to
+ * nothing gives an empty list. Derivable from the activity alone, which is what
+ * a validator of stored details joins against: by id AND by word, because
+ * positional ids alone cannot tell an edited transcript of the same length.
+ */
+declare function dictationReferenceWords(data: DictationReference): readonly (readonly {
+  itemId: string;
+  word: string;
+}[])[];
+/**
+ * Compares a learner's text with a dictation's transcript(s). Pure and
+ * deterministic: no locale, no `Intl`, integer alignment costs, one pinned
+ * tie order.
+ *
+ * The attempt is cut at `DICTATION_MAX_TEXT_LENGTH` code points before and
+ * after normalisation — a cut that ends on a space leaves no empty word after
+ * it — and `truncated` is also set when the rules grew its
+ * working text past the normaliser's bound (see `normalizeDictationText`).
+ * Every candidate — the transcript and at most
+ * `DICTATION_MAX_ACCEPTED_TRANSCRIPTS` accepted transcripts — is normalised
+ * with the same tolerance and cut at `DICTATION_MAX_TRANSCRIPT_LENGTH`; the
+ * attempt is scored against each surviving candidate and the first best wins.
+ * Words are then paired by a word-level edit distance with exact-equality
+ * costs, backtracked from the end preferring a pairing, then a missing
+ * transcript word, then an extra typed word; a paired word's similarity is its
+ * own character similarity.
+ */
+declare function alignDictation(data: DictationReference, text: string): DictationAlignment;
+//#endregion
+//#region src/scoring/dictation/chars.d.ts
+/** One code-point edit between a reference string and an attempt. */
+interface DictationCharOp {
+  op: 'equal' | 'substitute' | 'missing' | 'extra';
+  /** One code point of the reference, or `''` for an extra character. */
+  reference: string;
+  /** One code point of the attempt, or `''` for a missing character. */
+  attempt: string;
+}
+/**
+ * The code-point edit operations between two NORMALISED strings — the
+ * `reference` and `attempt` of a `DictationAlignment`, or one word pair from
+ * it — for a marked display: a character the learner typed right, typed
+ * wrong, left out, or added. Ties are broken preferring an equal or substituted
+ * pair, then a missing character, then an extra one, from the end of both
+ * strings; the number of non-`equal` ops is the edit distance.
+ *
+ * Decoration, never grading: it needs O(|reference|·|attempt|) memory, so the
+ * scorer does not call it, and a display computes it once per result.
+ */
+declare function diffDictationChars(reference: string, attempt: string): DictationCharOp[];
+//#endregion
+//#region src/scoring/dictation/normalize.d.ts
+/**
+ * The longest transcript a dictation accepts, in code points, before and after
+ * its equivalences are applied — and its rules may not grow it past twice
+ * `DICTATION_MAX_TEXT_LENGTH` on the way. A dictation is a sentence or two; the
+ * cap keeps the scorer's quadratic step bounded on the server that grades an
+ * exam.
+ */
+declare const DICTATION_MAX_TRANSCRIPT_LENGTH = 2000;
+/**
+ * The longest learner text the scorer compares, in code points. Text beyond it
+ * is cut off — before normalisation, and again after it, because a rewrite rule
+ * or a folded character can lengthen text — and the alignment says so.
+ */
+declare const DICTATION_MAX_TEXT_LENGTH = 8000;
+/** The longest `from` and `to` of an equivalence rule, in code points. */
+declare const DICTATION_MAX_EQUIVALENCE_LENGTH = 200;
+/**
+ * The most equivalence rules a dictation carries. The scorer reads no rule
+ * past this many, so stale data with more cannot slow a grading run.
+ */
+declare const DICTATION_MAX_EQUIVALENCES = 100;
+/**
+ * The most accepted transcripts a dictation carries. The scorer reads no more
+ * than this many, for the same reason.
+ */
+declare const DICTATION_MAX_ACCEPTED_TRANSCRIPTS = 10;
+//#endregion
+//#region src/scoring/item-scoring.d.ts
+/**
+ * The policy that changes nothing: one try, nothing costs anything, the first
+ * try counts. What an absent policy resolves to, and exactly how questions were
+ * scored before policies existed.
+ */
+declare const DEFAULT_ITEM_SCORING_POLICY: ResolvedItemScoringPolicy;
+/** The most tries after the first a policy can give. */
+declare const ITEM_SCORING_MAX_RETRIES = 10;
+/**
+ * Checks a policy before it is stored or used: every setting absent, `null`,
+ * or a value it can take — costs from 0 to 1, `retries` a whole number from 0
+ * to {@link ITEM_SCORING_MAX_RETRIES}, `counts` one of `first`, `best` or
+ * `last` — and no setting it does not know.
+ *
+ * It also refuses a `retryPenalty` above 0 while the first try counts: that
+ * cost can never be charged, and a school that set it believes retries cost
+ * something. Choose `counts: 'best'` or `'last'`.
+ */
+declare function validateItemScoringPolicy(policy: unknown): {
+  success: true;
+  data: ItemScoringPolicy;
+} | {
+  success: false;
+  issues: ItemScoringPolicyIssue[];
+};
+/**
+ * A policy with every setting spelled out.
+ *
+ * **It throws rather than guess.** A delivery policy reads a setting it cannot
+ * read as a restriction, because that is the safe way round; a setting here
+ * moves a grade, and there is no safe way round — a cost misread as 0 raises
+ * grades, misread as 1 lowers them. So a policy {@link validateItemScoringPolicy}
+ * refuses is refused here too, with a `RangeError` naming what is wrong, as an
+ * unreadable `rounding` is.
+ */
+declare function resolveItemScoringPolicy(policy: unknown): ResolvedItemScoringPolicy;
+/**
+ * A question's score under a policy, from its tries in the order they were
+ * made.
+ *
+ * - **What a try costs** is a fraction of the question's marks, subtracted
+ *   from what its answer scored: `hintPenalty` for every hint shown before it
+ *   (its `hintsRevealed`, which counts from the start of the question), and
+ *   `retryPenalty` for every try before it. A try never scores below 0.
+ * - **Which try counts** is the policy's `counts`: the first, the best after
+ *   costs (the earliest, where two are equal), or the last.
+ * - **Only the tries the policy allows are read**: the first `1 + retries`. A
+ *   record with more cannot have come from a learner under this policy.
+ *
+ * Nothing that cost nothing is changed: with no cost to charge, a try's score
+ * is exactly what its answer scored.
+ *
+ * @throws RangeError for a policy {@link resolveItemScoringPolicy} refuses, for
+ *         an empty list of tries, and for a try whose `score` and `maxScore`
+ *         cannot be a grade — the rule `outcomeFromGrade` applies: `maxScore`
+ *         positive and finite, `score` finite from 0 to it.
+ */
+declare function scoreTries(tries: readonly ItemTry[], policy?: ItemScoringPolicy | ResolvedItemScoringPolicy | null): ItemTriesScore;
+//#endregion
+//#region src/scoring/pass-threshold.d.ts
+/** Default minimum scaled score required to pass when `passThreshold` is absent. */
+declare const DEFAULT_PASS_THRESHOLD = 0.7;
+/**
+ * Returns `true` iff `score` meets or exceeds the activity's `passThreshold`,
+ * defaulting to {@link DEFAULT_PASS_THRESHOLD} (0.7) when the field is absent.
+ *
+ * Pass a {@link RoundingPolicy} to compare the way an assessment total is
+ * compared — both sides rounded, via {@link gte} — so an item shown as "70%"
+ * cannot be recorded as a fail at 69.6. It is **opt-in** rather than the
+ * default because switching it on changes item-level pass/fail for scores in
+ * the rounding band, and this SDK does not alter historical grades without an
+ * explicit decision. Absent, the comparison is the exact raw `>=` it has
+ * always been.
+ */
+declare function computePassThreshold(activityData: ActivityData, score: number, rounding?: RoundingPolicy): boolean;
+//#endregion
+//#region src/scoring/speech/align.d.ts
+/**
+ * Pairs the words of `assessment` with the words of `data.referenceText`, in
+ * reading order: what was read as written, what was mispronounced, what was
+ * left out, and what was said that the text does not contain.
+ *
+ * Reference words are the dictation tokeniser's, so `itemId` is the `w<n>`
+ * `dictationReferenceWords` gives, and both `reference` and `heard` are
+ * normalised — lowercased, with punctuation and spacing folded away. One
+ * assessor word can normalise to no token at all (a dash), or to several (a
+ * compatibility form), and two can merge into one (`rock&roll`); tokens are
+ * what is aligned, and each remembers the word it came from.
+ *
+ * A word the assessor tagged `insertion` is never aligned — the reference has
+ * nothing for it — so it is placed by the position of its own word, after the
+ * last token that came from an earlier word.
+ *
+ * Whether a paired word counts as read correctly follows `assessment.miscue`:
+ * an assessor that judges miscues is trusted, and one that does not
+ * (`miscue: 'none'`) has its recognised word compared with the reference word.
+ *
+ * `heard` is `''` for an omitted word, and also for an inserted word whose text
+ * normalises to nothing. Branch on `state`, never on the empty string.
+ *
+ * The heard tokens are bounded: they are taken in reading order until what the
+ * assessment's words spell would pass `DICTATION_MAX_TEXT_LENGTH` code points —
+ * the cap the dictation aligner reads a learner's text under — and always on a
+ * whole token, because half a token pairs with the wrong word. Every word is
+ * charged, an inserted one included, so that total is the whole of the text
+ * this function can answer with. Words past the budget contribute no token, so
+ * each reference word left with nothing read for it is `omitted`.
+ * `validateSpeechAssessment` refuses an assessment whose words spell more than
+ * that, measured by the same walk and against the same number, so a validated
+ * assessment never reaches the budget: it is a backstop, kept because this
+ * function is public and can be handed evidence this build did not check.
+ *
+ * **`data` is not validated.** Only the assessment is. A `referenceText` longer
+ * than `READ_ALOUD_MAX_REFERENCE_LENGTH` code points is cut by the tokeniser
+ * with no signal, and one that is absent or is not a string yields no reference
+ * word at all, so every heard token comes back `inserted` rather than refused.
+ * Validate the item with `validateActivity('read-aloud', data)` first.
+ * `gradeReadAloud` is safe without that because it runs the schema itself.
+ *
+ * Pure and deterministic: no locale, no `Intl`, no clock.
+ *
+ * @throws TypeError when `assessment` is not a well-formed
+ * {@link SpeechAssessment}; check it with `validateSpeechAssessment` first.
+ */
+declare function alignReadAloud(data: Pick<ReadAloudData, 'referenceText'>, assessment: SpeechAssessment): ReadAloudWordAlignment[];
+//#endregion
+//#region src/scoring/speech/assessment.d.ts
+/**
+ * Checks that `value` is a well-formed {@link SpeechAssessment}. It answers
+ * rather than throwing: anything that is not one — a non-object, an unknown key
+ * at any depth, a score off the 0..100 scale, a time that is negative or not
+ * finite — comes back as `{ success: false, errors }`, one error per problem,
+ * each with the path, message and code `validateActivity` gives a schema
+ * failure. An object that throws when it is read is the one exception, and the
+ * throw is its own: an own property getter, or a `Proxy` trap.
+ *
+ * Three rules span fields:
+ * - `scripted_binding_required` — a `scripted` assessment without
+ *   `referenceText`, or without `recordingKey`, reported at each missing path;
+ * - `phoneme_alphabet_required` — a phoneme names a `symbol` or `heardAs` while
+ *   `phonemeAlphabet` is absent, reported once, at `phonemeAlphabet`;
+ * - `too_big` at `words` — the words carry more text between them, written or
+ *   normalised, than can be aligned against an item's text. Per-word caps bound
+ *   no total, and the aligner pairs tokens, of which one word holds as many as
+ *   its text spells. Every word counts towards both totals, an insertion
+ *   included: the aligner carries one into its answer, so its text is text the
+ *   call must hold.
+ *
+ * The total is measured on the words every field rule accepted, so it says
+ * nothing about an assessment that is going back to its adapter anyway.
+ *
+ * It checks the evidence alone. Whether an assessment belongs to an item and
+ * to a learner's recording is decided when it is graded.
+ */
+declare function validateSpeechAssessment(value: unknown): ValidationResult<SpeechAssessment>;
+//#endregion
+//#region src/scoring/speech/grade.d.ts
+/**
+ * Grades a read-aloud take from a {@link SpeechAssessment} the application
+ * obtained, the response that was submitted, and the server's own measurement
+ * of the recording.
+ *
+ * The weighted total is computed by `gradeFromRubric` from the authored
+ * dimensions that carry a weight above 0, each out of 100. The per-word marks
+ * in `details` are for display and review: **they never feed the score**, which
+ * is the assessor's utterance-level judgement, weighted as the item authored it.
+ *
+ * Evidence is refused, never scored 0, when it cannot be tied to this item and
+ * this recording, when the assessor heard nothing, when the recording holds too
+ * little voiced time for the words claimed, or when a weighted dimension has no
+ * score — see {@link SpeechUnscorableCode}. Store a refusal with
+ * `outcomeFromUnscorable`.
+ *
+ * A blank (`response.recording === null`) is a grade of 0 with a mark per
+ * reference word: the learner submitted, and read nothing. The assessment and
+ * the measurement are not read for it.
+ *
+ * @throws RangeError when `options.plausibility` or `options.rounding` cannot be
+ * applied, or when `options.measured` is not a pair of non-negative, finite
+ * millisecond counts with `voicedMs` inside `durationMs`.
+ * @throws TypeError when `response` is not a read-aloud response, or when a
+ * non-blank response is graded without an assessment or without a measurement.
+ * @throws ActivitySchemaError when `data` is not valid read-aloud data.
+ * @throws RedactedScoringError when `data` is a `redact()` projection. A
+ * read-aloud projection is a valid activity, so the authored feedback would
+ * simply be missing from the grade; grade against the full data server-side.
+ */
+declare function gradeReadAloud(data: ReadAloudData, response: ReadAloudLearnerResponse, assessment: SpeechAssessment | null, options: GradeReadAloudOptions): GradeRecord | SpeechUnscorable;
+//#endregion
+//#region src/scoring/speech/limits.d.ts
+/**
+ * The longest reference text a read-aloud item accepts, in code points, before
+ * and after normalisation. It is the dictation transcript cap on purpose: the
+ * reference is tokenised as a dictation transcript is, and the dictation
+ * normaliser cuts a transcript at that many code points without saying so, so
+ * a longer text would be graded against words it had silently lost.
+ */
+declare const READ_ALOUD_MAX_REFERENCE_LENGTH = 2000;
+/** The longest take a read-aloud item may allow, in seconds: the most `recording.maxSeconds` may be. */
+declare const READ_ALOUD_MAX_SECONDS = 300;
+/** The most takes a read-aloud item may allow: the most `recording.maxTakes` may be. */
+declare const READ_ALOUD_MAX_TAKES = 20;
+/**
+ * The largest weight a read-aloud dimension may carry. Weights are relative, so
+ * no rubric needs more, and the cap keeps a mistyped weight from overflowing
+ * the weighted total into a grade that cannot be computed.
+ */
+declare const READ_ALOUD_MAX_DIMENSION_WEIGHT = 1000;
+/**
+ * The most words a speech assessment may carry. It bounds one side of the
+ * alignment, and one side alone bounds nothing: the aligner pairs TOKENS, and
+ * one word normalises to as many as its text holds. What bounds the quadratic
+ * work is this cap, the 200-unit cap on a single word's text, and the two rules
+ * `validateSpeechAssessment` states over the total of them — what the words are
+ * written with, and what they spell once normalised.
+ */
+declare const SPEECH_ASSESSMENT_MAX_WORDS = 1000;
+//#endregion
+//#region src/scoring/speech/wav.d.ts
+/**
+ * Reads a 16-bit PCM WAV and measures it: `durationMs`, `sampleRate`,
+ * `channels`, the loudest sample as `peakDbfs`, and `voicedMs`, the time in
+ * windows whose RMS level reaches the policy's silence floor.
+ *
+ * Anything it cannot measure comes back as `{ valid: false, reason }` rather
+ * than a guess: `not_wav` for bytes that are not a RIFF/WAVE file, or whose
+ * chunks do not describe the audio before the audio arrives;
+ * `unsupported_encoding` for a WAV this reader does not read (compressed, or
+ * samples that are not 16-bit); `truncated` when the data chunk is missing or
+ * shorter than it declares.
+ *
+ * Both policy fields are required, because neither has an answer that is right
+ * for every microphone: `silenceDbfs` is where an application draws the line
+ * between silence and speech, and `frameMs` is how finely it looks.
+ *
+ * Pure and deterministic. It never throws on the bytes themselves — only on
+ * arguments it cannot use.
+ *
+ * @throws TypeError when `bytes` is not a `Uint8Array`.
+ * @throws RangeError when `silenceDbfs` is not a finite number at or below 0,
+ * or `frameMs` is not a finite number above 0.
+ */
+declare function inspectWav(bytes: Uint8Array, policy: WavInspectionPolicy): WavInspection;
+//#endregion
+//#region src/scoring/unscorable.d.ts
+/**
+ * Lifts a result that cannot be graded — a `SpeechUnscorable` from
+ * `gradeReadAloud`, or anything else carrying a `code` and a `reason` — into
+ * the `unscorable` arm of {@link ItemOutcome}, keeping its code.
+ *
+ * The code is what an application branches on; the reason is a developer-facing
+ * sentence. Stored this way, the result composes exactly as the unscorable
+ * outcomes `evaluate` returns do. `evaluate` never writes a code itself.
+ */
+declare function outcomeFromUnscorable(result: {
+  code: string;
+  reason: string;
+}): ItemOutcome;
+//#endregion
+//#region src/scoring/index.d.ts
+/**
+ * Options for {@link score} and {@link evaluate}. Additive: with none, both
+ * behave exactly as they always have.
+ */
+interface ScoringOptions {
+  /**
+   * Compare the pass line the way the score is displayed — both sides rounded,
+   * via {@link computePassThreshold} — so an item shown as "70%" is not
+   * recorded as a fail at 69.995. `passed` AND the authored feedback selected by
+   * it follow the rounded comparison. Opt-in, for the reason
+   * {@link computePassThreshold} gives: switching it on moves item-level
+   * pass/fail for scores in the rounding band.
+   *
+   * Checked at the call: `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` instead of quietly failing every comparison.
+   */
+  rounding?: RoundingPolicy;
+}
+/**
+ * Options for {@link evaluate} and {@link evaluateTries}: {@link ScoringOptions},
+ * and the paper's scoring policy.
+ */
+interface EvaluateOptions extends ScoringOptions {
+  /**
+   * What hints and tries cost, and which try counts — see
+   * {@link ItemScoringPolicy}. Absent or `null`, nothing costs anything and the
+   * outcome is exactly what it was before policies existed.
+   *
+   * `evaluate` reads the hints from the response's `hintsRevealed`. The count
+   * is the client's: when your server knows better — it served the AI hints,
+   * say — write its own count there before you evaluate.
+   *
+   * Checked at the call: a policy `validateItemScoringPolicy` refuses throws a
+   * `RangeError`. A grade-moving setting has no safe way to be misread. Under a
+   * policy, a scored outcome whose numbers cannot be a grade — a registered
+   * scorer out of contract — has nothing to charge a cost to, and comes back
+   * `unscorable`.
+   */
+  scoring?: ItemScoringPolicy | null;
+}
+/**
+ * Scores a learner response against activity data and returns a full
+ * {@link ScoringResult}.
+ *
+ * Pure and deterministic with no side effects. It does **not** re-validate
+ * `activityData` — schema validation is the component boundary's
+ * responsibility; this is a low-level scoring primitive that trusts its typed
+ * inputs. Dispatch is registry-backed: consumer-registered types with `sync`
+ * scoring work here too. An unregistered type throws
+ * {@link UnknownActivityTypeError}; a type whose grading is deferred (e.g.
+ * `written-response`) throws {@link DeferredScoringError} — use
+ * {@link evaluate}, which can express "not graded yet".
+ */
+declare function score(activityType: ActivityType, activityData: ActivityData, learnerResponse: LearnerResponse, options?: ScoringOptions): ScoringResult;
+/**
+ * Evaluates a learner response against an activity and returns an
+ * {@link ItemOutcome} — the resilient, forward-compatible alternative to
+ * {@link score}:
+ *
+ * - Synchronously graded types return `{ status: 'scored', ... }` with the
+ *   same numbers `score()` produces.
+ * - Asynchronously graded types (e.g. `written-response`) return
+ *   `{ status: 'deferred', reason, partial }` instead of a fake zero — "not
+ *   graded yet" is expressible in the type system, never conflated with
+ *   "wrong".
+ * - An unregistered `data.type` returns `{ status: 'unscorable' }` rather
+ *   than throwing, so a mixed-version content bank cannot crash an exam run.
+ * - With a scoring policy (`options.scoring`), a scored outcome is charged what
+ *   the response's hints cost, and `passed` is read from what is left. The
+ *   `details` and authored `feedback` stay the answer's. For several tries at
+ *   one question, use {@link evaluateTries}.
+ *
+ * The activity type is read from `data.type` — there is no separate type
+ * parameter to disagree with the payload.
+ */
+declare function evaluate(data: ActivityData, response: LearnerResponse, options?: EvaluateOptions): ItemOutcome;
+/** A question's outcome over its tries: see {@link evaluateTries}. */
+interface ItemTriesOutcome {
+  /**
+   * The question's outcome under the policy. Scored: the counted try's
+   * `details` and authored `feedback` — they describe that answer — with its
+   * `score` after what it cost and `passed` read from that score. Anything
+   * else — deferred, unscorable — is the first try's outcome as `evaluate`
+   * gives it.
+   */
+  outcome: ItemOutcome;
+  /** 0-based: the try whose score counts. `null` when the outcome is not scored. */
+  counted: number | null;
+  /**
+   * Every try the policy allows, as scored: before and after what it cost.
+   * Empty when the outcome is not scored, or when, with no policy, it is an
+   * outcome `evaluate` passes through that cannot be a grade.
+   */
+  tries: ItemTryScore[];
+}
+/**
+ * A question's outcome from every try a learner made at it, in order, under a
+ * paper's scoring policy: what a server that scores practice itself calls,
+ * with the tries it stored, to reach the grade the SDK's components reached.
+ *
+ * Each response is scored as {@link evaluate} scores it, and costed and chosen
+ * as {@link scoreTries} does: hints from each response's `hintsRevealed`,
+ * which counts from the start of the question; the tries before each one;
+ * and the try `counts` names. Only the first `1 + retries` responses are read.
+ *
+ * With no policy it is `evaluate` of the first response: one try, as before.
+ * With no response at all, the question was never answered —
+ * `{ status: 'deferred', reason: 'no_response_recorded' }`, as a missing slot
+ * is everywhere else.
+ */
+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-BAfEHCnD.d.cts.map