@intellectif/lk-core 1.1.0 → 1.3.0

package/dist/scoring-BZqUkuDF.js

@@ -0,0 +1,1604 @@
+import { $ as dictationReferenceWords, C as SPEECH_ASSESSMENT_MAX_TEXT_LENGTH, J as RedactedScoringError, K as ActivitySchemaError, Q as alignSequences, X as STEP, Y as UnknownActivityTypeError, _ as ReadAloudDataSchema, at as codePointLength, j as countWords, ot as normalizeDictationText, q as DeferredScoringError, t as getActivityTypeDescriptor, v as CANONICAL_LOCALE_RE, w as SPEECH_ASSESSMENT_MAX_WORDS, yt as maxUnits } from "./registry-Dsx9mNsS.js";
+import * as z from "zod/v4";
+//#region src/scoring/grade-numbers.ts
+/**
+* How far past its own maximum a score may sit and still be a grade. A grader
+* that sums weighted parts lands on `1.0000000000000002` for a perfect answer
+* as readily as on `1`; that is float noise, not a grader out of contract.
+* Relative, so it means the same out of 100 as out of 1, and the same bound
+* lk-react applies before it shows a grade — the two packages agree on what a
+* grade is.
+*/
+const OVERSHOOT = 1e-9;
+/**
+* Whether `score` out of `maxScore` can be a grade: `maxScore` a positive,
+* finite number, and `score` a finite number from 0 to it. Anything else — NaN,
+* Infinity, a negative, 85 "out of 1", any score out of 0, a numeric string —
+* is a grader out of contract, and dividing by it puts a number on the record
+* that nobody can defend.
+*
+* A score up to `maxScore * OVERSHOOT` above its maximum passes as it is. It
+* is not clamped: an accepted grade composes exactly as it always has.
+*/
+function isGradeInRange(score, maxScore) {
+	return Number.isFinite(maxScore) && maxScore > 0 && Number.isFinite(score) && score >= 0 && score - maxScore <= maxScore * OVERSHOOT;
+}
+//#endregion
+//#region src/is-redacted.ts
+/**
+* True when `data` is a `redact()` projection rather than full activity data.
+* Grading a redacted item is always a bug: the answer key is gone by design, so
+* any "score" computed from it is meaningless — for a type whose projection
+* drops the key it used to come out `NaN`, and for one whose projection keeps
+* everything the grade reads it comes out as a plausible number with the
+* authored feedback silently missing.
+*
+* Internal, and its own module so that every grading entry point can ask the
+* same question: `score()` and `evaluate()` in `scoring/index.ts`, and
+* `gradeReadAloud` under `scoring/speech/`, which must not import the barrel
+* it is itself exported from.
+*/
+function isRedacted(data) {
+	return typeof data === "object" && data !== null && data.redacted === true;
+}
+//#endregion
+//#region src/scoring/item-scoring.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.
+*/
+const DEFAULT_ITEM_SCORING_POLICY = Object.freeze({
+	hintPenalty: 0,
+	retries: 0,
+	retryPenalty: 0,
+	counts: "first"
+});
+/** The most tries after the first a policy can give. */
+const ITEM_SCORING_MAX_RETRIES = 10;
+const SETTINGS = [
+	"hintPenalty",
+	"retries",
+	"retryPenalty",
+	"counts"
+];
+const COUNTS = [
+	"first",
+	"best",
+	"last"
+];
+const isUnset = (value) => value === void 0 || value === null;
+/** A cost: a finite number from 0 to 1. */
+const isFraction = (value) => typeof value === "number" && Number.isFinite(value) && value >= 0 && value <= 1;
+/**
+* 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'`.
+*/
+function validateItemScoringPolicy(policy) {
+	if (isUnset(policy)) return {
+		success: true,
+		data: {}
+	};
+	if (typeof policy !== "object" || Array.isArray(policy)) return {
+		success: false,
+		issues: [{
+			path: "",
+			message: "An item scoring policy is an object of settings."
+		}]
+	};
+	const given = policy;
+	const issues = [];
+	for (const key of Object.keys(given)) if (!SETTINGS.includes(key)) issues.push({
+		path: key,
+		message: `"${key}" is not an item scoring setting. The settings are hintPenalty, retries, retryPenalty and counts.`
+	});
+	for (const key of ["hintPenalty", "retryPenalty"]) {
+		const value = given[key];
+		if (!isUnset(value) && !isFraction(value)) issues.push({
+			path: key,
+			message: `"${key}" must be a number from 0 to 1: the fraction of a question's marks it costs.`
+		});
+	}
+	const retries = given.retries;
+	if (!isUnset(retries) && !(typeof retries === "number" && Number.isInteger(retries) && retries >= 0 && retries <= 10)) issues.push({
+		path: "retries",
+		message: `"retries" must be a whole number from 0 to 10.`
+	});
+	const counts = given.counts;
+	if (!isUnset(counts) && !COUNTS.includes(counts)) issues.push({
+		path: "counts",
+		message: "\"counts\" must be \"first\", \"best\" or \"last\"."
+	});
+	if (isFraction(given.retryPenalty) && given.retryPenalty > 0 && (isUnset(counts) || counts === "first")) issues.push({
+		path: "retryPenalty",
+		message: "\"retryPenalty\" is never charged while the first try counts. Set \"counts\" to \"best\" or \"last\", or leave \"retryPenalty\" out."
+	});
+	return issues.length > 0 ? {
+		success: false,
+		issues
+	} : {
+		success: true,
+		data: given
+	};
+}
+/**
+* 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.
+*/
+function resolveItemScoringPolicy(policy) {
+	if (isUnset(policy)) return DEFAULT_ITEM_SCORING_POLICY;
+	const checked = validateItemScoringPolicy(policy);
+	if (!checked.success) throw new RangeError(`learning-kit: this item scoring policy cannot be applied — ${checked.issues.map((issue) => `${issue.path || "policy"}: ${issue.message}`).join(" ")}`);
+	const given = checked.data;
+	return {
+		hintPenalty: given.hintPenalty ?? 0,
+		retries: given.retries ?? 0,
+		retryPenalty: given.retryPenalty ?? 0,
+		counts: given.counts ?? "first"
+	};
+}
+/** A hint count as the policy reads it: anything but a whole number of 0 or more is none. */
+function hintsRevealedOf(value) {
+	return typeof value === "number" && Number.isSafeInteger(value) && value > 0 ? value : 0;
+}
+/**
+* Removes the floating-point residue a cost leaves: `0.7 - 0.2` is
+* `0.49999999999999994`, which would fail a 0.5 pass line the learner met.
+* Twelve decimal places is far below anything a grade is shown or rounded to,
+* and far above the residue.
+*/
+function snap(value) {
+	return Math.round(value * 0xe8d4a51000) / 0xe8d4a51000;
+}
+/**
+* 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.
+*/
+function scoreTries(tries, policy) {
+	const rules = resolveItemScoringPolicy(policy);
+	if (tries.length === 0) throw new RangeError("scoreTries: there is no try to score.");
+	const scored = tries.slice(0, 1 + rules.retries).map((one, index) => {
+		const { score, maxScore } = one;
+		if (typeof score !== "number" || typeof maxScore !== "number" || !isGradeInRange(score, maxScore)) throw new RangeError(`scoreTries: try ${index + 1} has no score to cost — score ${String(score)} of ${String(maxScore)}.`);
+		const hintsRevealed = hintsRevealedOf(one.hintsRevealed);
+		const penalty = snap(rules.hintPenalty * hintsRevealed + rules.retryPenalty * index);
+		return {
+			score,
+			scored: penalty > 0 ? Math.max(0, snap(score / maxScore - penalty)) * maxScore : score,
+			maxScore,
+			hintsRevealed,
+			penalty
+		};
+	});
+	const ratio = (one) => one.scored / one.maxScore;
+	let counted = 0;
+	if (rules.counts === "last") counted = scored.length - 1;
+	else if (rules.counts === "best") scored.forEach((one, index) => {
+		if (ratio(one) > ratio(scored[counted])) counted = index;
+	});
+	const chosen = scored[counted];
+	return {
+		score: chosen.scored,
+		maxScore: chosen.maxScore,
+		counted,
+		tries: scored
+	};
+}
+//#endregion
+//#region src/scoring/rounding.ts
+const ROUNDING_MODES = [
+	"half-up",
+	"half-even",
+	"floor",
+	"ceil"
+];
+/** The most decimal places a policy may round to: a scaled grade stays an integer a double holds exactly. */
+const MAX_ROUNDING_DP = 15;
+/**
+* The rounding policy `value` holds, or `undefined` for none (`undefined` or
+* `null`). A malformed one would reach {@link gte} as `10 ** undefined` and
+* turn a perfect score into a fail with no error, so it throws here instead.
+*
+* Internal. Every function that takes a `rounding` option checks it here, so
+* each refuses the same policies with the same message; `scoring/index.ts`
+* does not re-export it.
+*/
+function roundingPolicyOf(value) {
+	if (value === void 0 || value === null) return;
+	const { mode, dp } = value;
+	if (!ROUNDING_MODES.includes(mode) || typeof dp !== "number" || !Number.isInteger(dp) || dp < 0 || dp > MAX_ROUNDING_DP) {
+		const describe = (field) => typeof field === "string" ? JSON.stringify(field) : typeof field === "number" || field === void 0 ? String(field) : typeof field === "object" ? "an object" : `a ${typeof field}`;
+		throw new RangeError(`Invalid rounding policy (mode ${describe(mode)}, dp ${describe(dp)}): expected { mode: 'half-up' | 'half-even' | 'floor' | 'ceil', dp: a whole number from 0 to ${MAX_ROUNDING_DP} }.`);
+	}
+	return {
+		mode,
+		dp
+	};
+}
+/**
+* Float-noise guard. Binary floating point makes `1.005 * 100` come out as
+* `100.49999999999999` and `0.29 * 100` come out as `28.999999999999996`;
+* without an allowance both would move a learner's grade a step. It is applied
+* in the direction each mode needs — see {@link roundGrade}.
+*/
+const EPSILON = 1e-9;
+/**
+* Tolerance for deciding "is this exactly halfway?" in half-even mode.
+* Deliberately much larger than {@link EPSILON}: if the tie test shared the
+* nudge's tolerance, the nudge would decide its own outcome. Safe for grades,
+* which live on a [0,1] scale where representation error is far below this.
+*/
+const TIE_TOLERANCE = 1e-6;
+function scaled(value, dp) {
+	return value * 10 ** dp;
+}
+/**
+* Normalises `-0` to `0` without touching anything else. `-0` JSON-serialises
+* as `0` but fails `Object.is(-0, 0)`, which surprises a strict-equality
+* gradebook comparison. Deliberately NOT `|| 0`: that also swallowed `NaN`
+* (reachable with an absurd `dp`, where `10 ** dp` overflows to Infinity) and
+* turned a visible failure into a plausible-looking grade of zero.
+*/
+function noNegZero(value) {
+	return Object.is(value, -0) ? 0 : value;
+}
+/**
+* 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.
+*/
+function roundGrade(value, policy) {
+	if (!Number.isFinite(value)) return value;
+	const factor = 10 ** policy.dp;
+	const raw = scaled(value, policy.dp);
+	switch (policy.mode) {
+		case "floor": return noNegZero(Math.floor(raw + EPSILON) / factor);
+		case "ceil": return noNegZero(Math.ceil(raw - EPSILON) / factor);
+		case "half-even": {
+			const floored = Math.floor(raw);
+			if (Math.abs(raw - floored - .5) > TIE_TOLERANCE) return noNegZero(halfAway(raw) / factor);
+			return noNegZero((floored % 2 === 0 ? floored : floored + 1) / factor);
+		}
+		default: return noNegZero(halfAway(raw) / factor);
+	}
+}
+/**
+* Half-up on a scaled value, with the sign-aware float-noise nudge.
+* `Math.round` breaks .5 ties toward +Infinity, so negatives are mirrored to
+* keep the tie breaking away from zero in both directions.
+*/
+function halfAway(raw) {
+	const nudged = raw >= 0 ? raw + EPSILON : raw - EPSILON;
+	return raw >= 0 ? Math.round(nudged) : -Math.round(-nudged);
+}
+/**
+* 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.
+*/
+function gte(value, threshold, policy) {
+	return roundGrade(value, policy) >= roundGrade(threshold, policy) - EPSILON;
+}
+/**
+* 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.
+*/
+function classifyBand(value, bands) {
+	let best = null;
+	for (const band of bands) if (value >= band.min - EPSILON && (best === null || band.min > best.min)) best = band;
+	return best;
+}
+//#endregion
+//#region src/scoring/pass-threshold.ts
+/** Default minimum scaled score required to pass when `passThreshold` is absent. */
+const DEFAULT_PASS_THRESHOLD = .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.
+*/
+function computePassThreshold(activityData, score, rounding) {
+	const threshold = activityData.passThreshold ?? .7;
+	return rounding === void 0 ? score >= threshold : gte(score, threshold, rounding);
+}
+/**
+* Selects the authored overall feedback for a result: `feedback.correct` when
+* the learner passed, `feedback.incorrect` otherwise; `null` when no matching
+* message was authored. Mirrors the selection the lk-react components applied
+* (keyed on `passed`, per the `ActivityFeedback` contract).
+*/
+function selectFeedback(activityData, passed) {
+	const feedback = activityData.feedback;
+	if (feedback === void 0) return null;
+	return (passed ? feedback.correct : feedback.incorrect) ?? null;
+}
+//#endregion
+//#region src/grading.ts
+/**
+* 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.
+*/
+function gradeFromRubric(criteria, activityData, options = {}) {
+	const rounding = roundingPolicyOf(options?.rounding);
+	const corrupt = criteria.find((criterion) => criterion.notApplicable !== true && criterion.score !== void 0 && !Number.isFinite(criterion.score));
+	if (corrupt !== void 0) return {
+		unscorable: true,
+		reason: `Criterion "${corrupt.name}" has a non-finite score (${String(corrupt.score)}). A grade cannot be computed from it.`
+	};
+	const badMax = criteria.find((criterion) => criterion.notApplicable !== true && criterion.maxScore !== void 0 && !(Number.isFinite(criterion.maxScore) && criterion.maxScore > 0));
+	if (badMax !== void 0) return {
+		unscorable: true,
+		reason: `Criterion "${badMax.name}" declares maxScore ${String(badMax.maxScore)}; it must be a positive, finite number.`
+	};
+	const scoreable = criteria.filter((criterion) => criterion.notApplicable !== true && typeof criterion.score === "number");
+	/** The criterion's score as a ratio in [0,1]. `maxScore` defaults to 1. */
+	const ratioOf = (criterion) => criterion.score / (criterion.maxScore ?? 1);
+	const outOfRange = scoreable.find((criterion) => ratioOf(criterion) < -1e-9 || ratioOf(criterion) > 1.000000001);
+	if (outOfRange !== void 0) return {
+		unscorable: true,
+		reason: `Criterion "${outOfRange.name}" has score ${outOfRange.score} out of ${outOfRange.maxScore ?? 1}, which is outside the [0,1] range once scaled. Set \`maxScore\` on the criterion to declare what the score is out of (e.g. \`maxScore: 100\` for a 0–100 grader).`
+	};
+	if (scoreable.length === 0) return {
+		unscorable: true,
+		reason: "No criterion carried a numeric score, so no weighted total can be computed."
+	};
+	const totalWeight = scoreable.reduce((sum, criterion) => sum + (criterion.weight ?? 1), 0);
+	if (!(totalWeight > 0)) return {
+		unscorable: true,
+		reason: "Criterion weights do not sum to a positive number, so the weighted total is undefined."
+	};
+	const negativeWeight = scoreable.find((criterion) => (criterion.weight ?? 1) < 0);
+	if (negativeWeight !== void 0) return {
+		unscorable: true,
+		reason: `Criterion "${negativeWeight.name}" has weight ${String(negativeWeight.weight)}; a weight must be zero or more.`
+	};
+	const rawScore = scoreable.reduce((sum, criterion) => sum + ratioOf(criterion) * (criterion.weight ?? 1), 0) / totalWeight;
+	if (!Number.isFinite(totalWeight) || !Number.isFinite(rawScore)) return {
+		unscorable: true,
+		reason: "The weighted total is not a finite number, so no grade can be produced."
+	};
+	const score = Math.min(1, Math.max(0, rawScore));
+	const reaches = (threshold) => rounding === void 0 ? score >= threshold : gte(score, threshold, rounding);
+	return {
+		score,
+		maxScore: 1,
+		passed: options.passThreshold !== void 0 ? reaches(options.passThreshold) : activityData !== void 0 ? computePassThreshold(activityData, score, rounding) : reaches(.7),
+		feedback: options.feedback ?? null,
+		criteria: [...criteria]
+	};
+}
+/**
+* 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`.
+*/
+function outcomeFromGrade(grade) {
+	const { score, maxScore } = grade;
+	if (!isGradeInRange(score, maxScore)) return {
+		status: "deferred",
+		reason: "grade_rejected",
+		maxScore: 1,
+		rejectedGrade: grade
+	};
+	return {
+		status: "graded",
+		grade,
+		score,
+		maxScore,
+		passed: grade.passed,
+		feedback: grade.feedback
+	};
+}
+/**
+* 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.
+*/
+function hasGrade(outcome) {
+	return outcome.status === "scored" || outcome.status === "graded";
+}
+//#endregion
+//#region src/scoring/compose.ts
+function earned(item) {
+	const { outcome } = item;
+	if (hasGrade(outcome)) {
+		const { score, maxScore } = outcome;
+		if (!isGradeInRange(score, maxScore)) return { state: "rejected" };
+		return {
+			state: "graded",
+			points: score / maxScore * item.points
+		};
+	}
+	if (outcome.status === "deferred") return outcome.reason === "grade_rejected" ? { state: "rejected" } : { state: "pending" };
+	return { state: "unscorable" };
+}
+/**
+* The `rejectedSlotIds` field, present only when something was rejected: a
+* result with none is then exactly what earlier versions returned, and the
+* grade-stability corpus compares results exactly.
+*/
+function rejectedField(slotIds) {
+	return slotIds.length > 0 ? { rejectedSlotIds: slotIds } : {};
+}
+/**
+* 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`.
+*/
+function composeAssessmentScore(sections, policy) {
+	const pendingAll = [];
+	const rejectedAll = [];
+	const unscorableAll = [];
+	const partials = sections.map((section) => {
+		let earnedPoints = 0;
+		let gradedMaxPoints = 0;
+		let maxPoints = 0;
+		const pendingSlotIds = [];
+		const rejectedSlotIds = [];
+		const unscorableSlotIds = [];
+		for (const item of section.items) {
+			maxPoints += item.points;
+			const contribution = earned(item);
+			if (contribution.state === "pending" || contribution.state === "rejected") {
+				pendingSlotIds.push(item.slotId);
+				pendingAll.push(item.slotId);
+				if (contribution.state === "rejected") {
+					rejectedSlotIds.push(item.slotId);
+					rejectedAll.push(item.slotId);
+				}
+				continue;
+			}
+			if (contribution.state === "unscorable") {
+				unscorableSlotIds.push(item.slotId);
+				unscorableAll.push(item.slotId);
+				continue;
+			}
+			earnedPoints += contribution.points;
+			gradedMaxPoints += item.points;
+		}
+		const raw = gradedMaxPoints > 0 ? earnedPoints / gradedMaxPoints : 0;
+		const appliedThreshold = section.passThresholdOverride ?? policy.sectionThreshold ?? null;
+		return {
+			section,
+			earnedPoints,
+			gradedMaxPoints,
+			maxPoints,
+			score: roundGrade(raw, policy.rounding),
+			appliedThreshold,
+			pendingSlotIds,
+			rejectedSlotIds,
+			unscorableSlotIds
+		};
+	});
+	const contributingWeight = partials.reduce((sum, partial) => sum + (partial.gradedMaxPoints > 0 ? partial.section.weight : 0), 0);
+	const scored = partials.map((partial) => ({
+		id: partial.section.id,
+		...partial.section.title !== void 0 ? { title: partial.section.title } : {},
+		weight: partial.section.weight,
+		normalizedWeight: partial.gradedMaxPoints > 0 && contributingWeight > 0 ? partial.section.weight / contributingWeight : 0,
+		earnedPoints: partial.earnedPoints,
+		gradedMaxPoints: partial.gradedMaxPoints,
+		maxPoints: partial.maxPoints,
+		score: partial.score,
+		passed: partial.appliedThreshold === null || partial.gradedMaxPoints === 0 ? true : gte(partial.score, partial.appliedThreshold, policy.rounding),
+		appliedThreshold: partial.appliedThreshold,
+		pendingSlotIds: partial.pendingSlotIds,
+		...rejectedField(partial.rejectedSlotIds),
+		unscorableSlotIds: partial.unscorableSlotIds
+	}));
+	const score = roundGrade(scored.reduce((sum, section) => sum + section.score * section.normalizedWeight, 0), policy.rounding);
+	const status = pendingAll.length > 0 ? "provisional" : "final";
+	if (status === "provisional") return {
+		sections: scored,
+		score,
+		passed: null,
+		passFailureReason: null,
+		status,
+		pendingSlotIds: pendingAll,
+		...rejectedField(rejectedAll),
+		unscorableSlotIds: unscorableAll
+	};
+	if (scored.every((section) => section.gradedMaxPoints === 0)) return {
+		sections: scored,
+		score,
+		passed: null,
+		passFailureReason: null,
+		status,
+		pendingSlotIds: pendingAll,
+		...rejectedField(rejectedAll),
+		unscorableSlotIds: unscorableAll
+	};
+	const overallOk = gte(score, policy.passThreshold, policy.rounding);
+	const sectionsOk = scored.every((section) => section.passed);
+	const passed = overallOk && sectionsOk;
+	return {
+		sections: scored,
+		score,
+		passed,
+		passFailureReason: passed ? null : !overallOk && !sectionsOk ? "both" : overallOk ? "section_below_threshold" : "overall_below_threshold",
+		status,
+		pendingSlotIds: pendingAll,
+		...rejectedField(rejectedAll),
+		unscorableSlotIds: unscorableAll
+	};
+}
+//#endregion
+//#region src/scoring/dictation/chars.ts
+/**
+* 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.
+*/
+function diffDictationChars(reference, attempt) {
+	const referencePoints = Array.from(reference);
+	const attemptPoints = Array.from(attempt);
+	return alignSequences(referencePoints, attemptPoints).map(({ step, referenceIndex, attemptIndex }) => {
+		if (step === STEP.missing) return {
+			op: "missing",
+			reference: referencePoints[referenceIndex],
+			attempt: ""
+		};
+		if (step === STEP.extra) return {
+			op: "extra",
+			reference: "",
+			attempt: attemptPoints[attemptIndex]
+		};
+		const referencePoint = referencePoints[referenceIndex];
+		const attemptPoint = attemptPoints[attemptIndex];
+		return {
+			op: referencePoint === attemptPoint ? "equal" : "substitute",
+			reference: referencePoint,
+			attempt: attemptPoint
+		};
+	});
+}
+//#endregion
+//#region src/scoring/speech/tokens.ts
+/**
+* The normalised tokens of the words that can be marked, each remembering the
+* word it came from, up to what {@link SPEECH_ASSESSMENT_MAX_TEXT_LENGTH} code
+* points of text hold.
+*
+* A word the assessor tagged `insertion` gives no token — the reference has
+* nothing for it to pair with, so it is placed by its own position afterwards —
+* but its text IS charged to the length, because the aligner normalises it
+* anyway and emits it as an entry of its own. Charging it is what makes the
+* length the whole of what an assessment spells, so the bound the validator
+* states over it is the bound that holds. A word that normalises to nothing
+* spells nothing and is charged nothing.
+*
+* The length counts what the words spell as one text, so the space that joins a
+* token to the last one counts with it: the aligner's matrix is one byte per
+* token per reference word, and it is that text, not the words it was written
+* as, that decides how big it grows. Collecting stops at the first token that
+* would pass the budget, never inside one, because half a token pairs with the
+* wrong reference word and marks a reading nobody gave.
+*/
+function heardTokens(words) {
+	const tokens = [];
+	let length = 0;
+	for (const [wordIndex, word] of words.entries()) {
+		const normalized = normalizeDictationText(word.text);
+		if (normalized === "") continue;
+		const inserted = word.error === "insertion";
+		for (const text of normalized.split(" ")) {
+			length += codePointLength(text) + (length === 0 ? 0 : 1);
+			if (!inserted && length <= SPEECH_ASSESSMENT_MAX_TEXT_LENGTH) tokens.push({
+				text,
+				wordIndex
+			});
+		}
+	}
+	return {
+		tokens,
+		length
+	};
+}
+//#endregion
+//#region src/scoring/speech/assessment.ts
+/** A score on the assessment's 0..100 scale. `z.number()` refuses NaN and both infinities. */
+const Score = z.number().min(0).max(100);
+/** A confidence, 0..1. */
+const Confidence = z.number().min(0).max(1);
+/** A time from the start of the recording, or a length of time, in milliseconds. */
+const Milliseconds = z.number().min(0);
+const PhonemeCandidateSchema = z.strictObject({
+	symbol: maxUnits(z.string().min(1), 16),
+	score: Score
+});
+const PhonemeSchema = z.strictObject({
+	symbol: maxUnits(z.string().min(1), 16).optional(),
+	accuracy: Score.optional(),
+	startMs: Milliseconds.optional(),
+	durationMs: Milliseconds.optional(),
+	heardAs: z.array(PhonemeCandidateSchema).max(10).optional()
+});
+const SyllableSchema = z.strictObject({
+	text: maxUnits(z.string().min(1), 64),
+	grapheme: maxUnits(z.string(), 64).optional(),
+	accuracy: Score.optional(),
+	startMs: Milliseconds.optional(),
+	durationMs: Milliseconds.optional()
+});
+const WordSchema = z.strictObject({
+	text: maxUnits(z.string().min(1), 200),
+	accuracy: Score.optional(),
+	error: z.enum([
+		"none",
+		"mispronunciation",
+		"omission",
+		"insertion"
+	]),
+	vendorError: maxUnits(z.string(), 64).optional(),
+	startMs: Milliseconds.optional(),
+	durationMs: Milliseconds.optional(),
+	syllables: z.array(SyllableSchema).max(50).optional(),
+	phonemes: z.array(PhonemeSchema).max(50).optional(),
+	breaks: z.strictObject({
+		unexpected: Confidence.optional(),
+		missing: Confidence.optional()
+	}).optional()
+});
+const AssessorSchema = z.strictObject({
+	kind: z.enum([
+		"auto",
+		"ai",
+		"human"
+	]),
+	id: maxUnits(z.string(), 256).optional(),
+	model: maxUnits(z.string(), 256).optional(),
+	promptHash: maxUnits(z.string(), 256).optional()
+});
+const SpeechAssessmentSchema = z.strictObject({
+	assessmentVersion: z.literal("1.0"),
+	status: z.enum(["assessed", "no_speech"]),
+	task: z.enum(["scripted", "unscripted"]),
+	locale: z.string().regex(CANONICAL_LOCALE_RE),
+	referenceText: maxUnits(z.string(), 8e3).optional(),
+	recordingKey: maxUnits(z.string().min(1), 1024).optional(),
+	assessor: AssessorSchema,
+	scale: z.literal(100),
+	scores: z.strictObject({
+		accuracy: Score.optional(),
+		fluency: Score.optional(),
+		completeness: Score.optional(),
+		prosody: Score.optional(),
+		overall: Score.optional()
+	}),
+	recognizedText: maxUnits(z.string(), 8e3).optional(),
+	miscue: z.enum(["assessor", "none"]),
+	phonemeAlphabet: z.enum(["ipa", "sapi"]).optional(),
+	words: z.array(WordSchema).max(SPEECH_ASSESSMENT_MAX_WORDS),
+	prosody: z.strictObject({ monotoneConfidence: Confidence.optional() }).optional(),
+	signal: z.strictObject({ snrDb: z.number().optional() }).optional()
+});
+const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+/** Whether any phoneme of any word names a `symbol`, or lists what was `heardAs` instead. */
+function namesPhonemes(words) {
+	return Array.isArray(words) && words.some((word) => {
+		const phonemes = isRecord(word) ? word.phonemes : void 0;
+		return Array.isArray(phonemes) && phonemes.some((phoneme) => isRecord(phoneme) && (phoneme.symbol !== void 0 || phoneme.heardAs !== void 0));
+	});
+}
+/** How much text the words are written with between them, in UTF-16 units. */
+function rawTextLength(words) {
+	let total = 0;
+	for (const word of words) total += word.text.length;
+	return total;
+}
+/**
+* The two rules over the total text of the words, reported at `words`. They run
+* on the value zod parsed — the words as they were read, never as a second read
+* of the argument describes them — because a bound computed from a value the
+* aligner will not see bounds nothing.
+*
+* Both are needed, and neither replaces the other:
+*
+* - the **raw** total is what the words are written with. It is linear and
+*   normalises nothing, so it refuses the 200 000-unit assessment the per-word
+*   caps allow between them without paying the cost it exists to prevent, and
+*   it runs first;
+* - the **normalised** total is what those words spell once they are folded into
+*   tokens, which is what the aligner actually pairs. A compatibility character
+*   can stand for eighteen, so a reading well inside the raw cap can still spell
+*   more text than the aligner reads — and the words past that are dropped in
+*   silence, leaving the learner marked from the noise that came before them.
+*   It is measured by the very function that collects those tokens, so the two
+*   bounds are one bound.
+*
+* Both count every word the assessment carries, so neither can be walked past
+* by tagging text `insertion`: an inserted word gives no token to pair, but the
+* aligner still normalises it and emits it, so its text is text the call holds.
+*
+* One error at most: the second runs only on what the first let through, so it
+* never normalises more than the raw cap allows.
+*/
+function totalTextErrors(words) {
+	const raw = rawTextLength(words);
+	if (raw > SPEECH_ASSESSMENT_MAX_TEXT_LENGTH) return [{
+		path: ["words"],
+		message: `The words of an assessment carry ${raw} characters between them, and at most ${SPEECH_ASSESSMENT_MAX_TEXT_LENGTH} can be aligned against the text of an item.`,
+		code: "too_big"
+	}];
+	const normalized = heardTokens(words).length;
+	if (normalized > SPEECH_ASSESSMENT_MAX_TEXT_LENGTH) return [{
+		path: ["words"],
+		message: `The words of an assessment spell ${normalized} characters between them once they are normalised, and at most ${SPEECH_ASSESSMENT_MAX_TEXT_LENGTH} can be aligned against the text of an item. One character can stand for several.`,
+		code: "too_big"
+	}];
+	return [];
+}
+/**
+* The two rules no single field states, and no parsed value can answer: each
+* fires on a field that is ABSENT. They read the value as it was given, not as
+* zod parsed it, so they report beside the field rules instead of waiting for
+* every field to parse — an adapter sees each problem on its first run — and
+* because a field zod refused is missing from what it parsed.
+*/
+function crossFieldErrors(value) {
+	const errors = [];
+	if (value.task === "scripted") {
+		if (value.referenceText === void 0) errors.push({
+			path: ["referenceText"],
+			message: "A scripted assessment must carry the reference text it was made against, so a grade can confirm it is the text of the item.",
+			code: "scripted_binding_required"
+		});
+		if (value.recordingKey === void 0) errors.push({
+			path: ["recordingKey"],
+			message: "A scripted assessment must carry the key of the recording it measured, so a grade can confirm it is the recording of the learner.",
+			code: "scripted_binding_required"
+		});
+	}
+	if (value.phonemeAlphabet === void 0 && namesPhonemes(value.words)) errors.push({
+		path: ["phonemeAlphabet"],
+		message: "A phoneme names a symbol or what was heard instead, so the assessment must say which phonemeAlphabet those symbols are written in.",
+		code: "phoneme_alphabet_required"
+	});
+	return errors;
+}
+/**
+* One validation error as a phrase a developer can act on: the path it was
+* reported at, then the message. A refusal at the root has no path, and the
+* message already names the value.
+*
+* Internal: it is what `alignReadAloud`'s `TypeError` and `gradeReadAloud`'s
+* `invalid_assessment` reason say about the first problem they found, so the
+* two name it the same way.
+*/
+function describeValidationError(error) {
+	return error.path.length === 0 ? error.message : `${error.path.join(".")}: ${error.message}`;
+}
+/**
+* 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.
+*/
+function validateSpeechAssessment(value) {
+	const result = SpeechAssessmentSchema.safeParse(value);
+	const refused = result.success ? [] : result.error.issues.map((issue) => ({
+		path: issue.path.map(String),
+		message: issue.message,
+		code: issue.code
+	}));
+	const parsed = result.success ? result.data : void 0;
+	const errors = isRecord(value) ? [
+		...refused,
+		...crossFieldErrors(value),
+		...parsed !== void 0 ? totalTextErrors(parsed.words) : []
+	] : refused;
+	if (parsed !== void 0 && errors.length === 0) return {
+		success: true,
+		data: parsed
+	};
+	return {
+		success: false,
+		errors
+	};
+}
+//#endregion
+//#region src/scoring/speech/align.ts
+/**
+* The word's accuracy when it has one. Absent means the assessor did not
+* measure the word, which is never the same as measuring it at 0.
+*/
+function accuracyOf(word) {
+	return word.accuracy !== void 0 ? { accuracy: word.accuracy } : {};
+}
+/**
+* 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.
+*/
+function alignReadAloud(data, assessment) {
+	const checked = validateSpeechAssessment(assessment);
+	if (!checked.success) throw new TypeError(`alignReadAloud was given something that is not a speech assessment (${describeValidationError(checked.errors[0])}). Check it with validateSpeechAssessment before aligning it.`);
+	return alignValidated(data, checked.data);
+}
+/**
+* {@link alignReadAloud} for a caller that has already validated the
+* assessment, and holds the value the validator handed back.
+*
+* Internal: it is how `gradeReadAloud` aligns what it just checked, rather than
+* paying for the same parse twice — the cost of which is the whole assessment,
+* words, syllables and phonemes, on every grade.
+*/
+function alignValidated(data, assessment) {
+	const reference = dictationReferenceWords({ transcript: data.referenceText })[0];
+	const heard = heardTokens(assessment.words).tokens;
+	const entries = [];
+	for (const { step, referenceIndex, attemptIndex } of alignSequences(reference.map((word) => word.word), heard.map((token) => token.text))) {
+		if (step === STEP.extra) {
+			const token = heard[attemptIndex];
+			entries.push({
+				reference: "",
+				heard: token.text,
+				state: "inserted",
+				...accuracyOf(assessment.words[token.wordIndex]),
+				wordIndex: token.wordIndex
+			});
+			continue;
+		}
+		const referenceWord = reference[referenceIndex];
+		if (step === STEP.missing) {
+			entries.push({
+				itemId: referenceWord.itemId,
+				reference: referenceWord.word,
+				heard: "",
+				state: "omitted"
+			});
+			continue;
+		}
+		const token = heard[attemptIndex];
+		const word = assessment.words[token.wordIndex];
+		const state = pairedState(word, assessment.miscue, referenceWord.word, token.text);
+		entries.push({
+			itemId: referenceWord.itemId,
+			reference: referenceWord.word,
+			heard: state === "omitted" ? "" : token.text,
+			state,
+			...accuracyOf(word),
+			wordIndex: token.wordIndex
+		});
+	}
+	placeInsertions(assessment, entries);
+	return entries;
+}
+/** How a reference word paired with a heard token is marked. */
+function pairedState(word, miscue, reference, heard) {
+	if (word.error === "omission") return "omitted";
+	if (word.error === "mispronunciation") return "mispronounced";
+	if (miscue === "none" && heard !== reference) return "mispronounced";
+	return "correct";
+}
+/**
+* Splices in one entry per `insertion` word. An inserted word has no reference
+* word to align with, so it is placed by its own position among the assessor's
+* words: immediately after the last entry that came from an earlier word, or
+* first when nothing came before it. Several in a row keep the order the
+* assessor reported them in, because each is placed after the one before it.
+*/
+function placeInsertions(assessment, entries) {
+	assessment.words.forEach((word, wordIndex) => {
+		if (word.error !== "insertion") return;
+		let at = 0;
+		entries.forEach((entry, index) => {
+			if (entry.wordIndex !== void 0 && entry.wordIndex < wordIndex) at = index + 1;
+		});
+		entries.splice(at, 0, {
+			reference: "",
+			heard: normalizeDictationText(word.text),
+			state: "inserted",
+			...accuracyOf(word),
+			wordIndex
+		});
+	});
+}
+//#endregion
+//#region src/scoring/speech/grade.ts
+/**
+* The read-aloud grade: the arithmetic over a pronunciation assessment's
+* dimension scores, and the checks that decide whether that evidence may be
+* graded at all.
+*
+* The SDK calls no assessor and holds no key. It is given the application's
+* assessment and the server's own measurement of the recording, and it refuses
+* evidence it cannot tie to this item, this text and this recording — a refusal
+* is never a zero, because a learner who was not heard has not failed.
+*/
+/**
+* Float slack when comparing two measurements of the same recording: voiced
+* time is summed window by window, so it can land a hair above the duration it
+* was measured from without either number being wrong.
+*/
+const MEASUREMENT_TOLERANCE = 1e-6;
+/** What every assessor score is out of, and what a criterion declares. */
+const ASSESSMENT_SCALE = 100;
+/** A value named in an error message, without serialising the object it came from. */
+function describeValue$1(value) {
+	return typeof value === "number" ? String(value) : `of type ${typeof value}`;
+}
+/**
+* The recording a response carries, checked and copied — or `undefined` when
+* the value is not a response this grade can read.
+*
+* It answers with a copy for the same reason the item and the assessment are
+* graded from their checked copies: the response has no schema to parse it, so
+* this is the only place its fields are read. An accessor that answered a take
+* here and `null` afterwards would have graded a real reading as a blank 0, and
+* one that answered another key afterwards would have walked past the
+* recording-key binding. Every field is read once, and what is returned is what
+* was checked.
+*/
+function readResponseRecording(value) {
+	if (typeof value !== "object" || value === null) return;
+	const { type, recording } = value;
+	if (type !== "read-aloud") return;
+	if (recording === null) return { recording: null };
+	if (typeof recording !== "object") return;
+	const { key, mimeType } = recording;
+	if (typeof key !== "string" || key === "" || typeof mimeType !== "string") return;
+	return { recording: {
+		key,
+		mimeType
+	} };
+}
+/**
+* How many words were spoken, for the speech-rate check: what the assessor
+* recognised as text when it reported any, and otherwise the words it kept —
+* an omission was not spoken, and an insertion is not in the text.
+*
+* `countWords` is the counter on purpose: it is the one the SDK already counts
+* a written response with, and a rate compared against a policy an application
+* set must be counted the same way every time.
+*/
+function spokenWordCount(assessment) {
+	const recognized = assessment.recognizedText;
+	if (recognized !== void 0 && recognized.trim() !== "") return countWords(recognized);
+	return countWords(assessment.words.filter((word) => word.error !== "omission" && word.error !== "insertion").map((word) => word.text).join(" "));
+}
+/**
+* The mark for one reference word: nothing was read for an omitted word, and a
+* word the assessor did not measure carries no mark at all — an absent score is
+* not a zero.
+*/
+function scoreOf(entry) {
+	if (entry.state === "omitted") return { score: 0 };
+	return entry.accuracy !== void 0 ? { score: entry.accuracy / ASSESSMENT_SCALE } : {};
+}
+/**
+* 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.
+*/
+function gradeReadAloud(data, response, assessment, options) {
+	const maxWordsPerSecond = options?.plausibility?.maxWordsPerSecond;
+	if (typeof maxWordsPerSecond !== "number" || !Number.isFinite(maxWordsPerSecond) || maxWordsPerSecond <= 0) throw new RangeError(`Invalid plausibility policy (maxWordsPerSecond ${describeValue$1(maxWordsPerSecond)}): expected a finite number above 0.`);
+	const minVoicedMs = options?.plausibility?.minVoicedMs;
+	if (typeof minVoicedMs !== "number" || !Number.isFinite(minVoicedMs) || minVoicedMs < 0) throw new RangeError(`Invalid plausibility policy (minVoicedMs ${describeValue$1(minVoicedMs)}): expected a finite number of milliseconds, 0 or above.`);
+	const rounding = roundingPolicyOf(options?.rounding);
+	const parsed = ReadAloudDataSchema.safeParse(data);
+	if (!parsed.success) throw new ActivitySchemaError("read-aloud", parsed.error.issues.map((issue) => ({
+		path: issue.path.map(String),
+		message: issue.message,
+		code: issue.code
+	})));
+	if (isRedacted(data) || isRedacted(parsed.data)) throw new RedactedScoringError("read-aloud");
+	const item = parsed.data;
+	const checkedResponse = readResponseRecording(response);
+	if (checkedResponse === void 0) throw new TypeError("gradeReadAloud needs a read-aloud response: { type: \"read-aloud\", recording: null } for a blank, or a recording with a non-empty `key` and a `mimeType`.");
+	const recording = checkedResponse.recording;
+	if (recording === null) {
+		const passed = computePassThreshold(item, 0, rounding);
+		return {
+			score: 0,
+			maxScore: 1,
+			passed,
+			feedback: selectFeedback(item, passed),
+			criteria: [],
+			details: referenceWordsOf(item).map(({ itemId, word }) => ({
+				itemId,
+				outcome: "incorrect-omission",
+				learnerResponse: "",
+				correctResponse: word,
+				weight: 1,
+				score: 0
+			}))
+		};
+	}
+	if (assessment === null || assessment === void 0) throw new TypeError("gradeReadAloud needs a speech assessment for a response that carries a recording. Pass one, or grade the blank (recording: null).");
+	const measured = options.measured;
+	if (measured === null || measured === void 0) throw new TypeError("gradeReadAloud needs `options.measured`, the server's own measurement of the recording (inspectWav), for a response that carries a recording. A duration the client reported is not evidence.");
+	const { durationMs, voicedMs } = measured;
+	if (typeof durationMs !== "number" || !Number.isFinite(durationMs) || durationMs < 0 || typeof voicedMs !== "number" || !Number.isFinite(voicedMs) || voicedMs < 0 || voicedMs > durationMs + MEASUREMENT_TOLERANCE) throw new RangeError(`Invalid recording measurement (durationMs ${describeValue$1(durationMs)}, voicedMs ${describeValue$1(voicedMs)}): expected finite millisecond counts, 0 or above, with voicedMs inside durationMs.`);
+	const unscorable = (code, reason) => ({
+		unscorable: true,
+		code,
+		reason
+	});
+	const checked = validateSpeechAssessment(assessment);
+	if (!checked.success) return unscorable("invalid_assessment", `The speech assessment is not well formed (${describeValidationError(checked.errors[0])}).`);
+	const evidence = checked.data;
+	if (evidence.task !== "scripted") return unscorable("task_mismatch", `The assessment was made for a "${evidence.task}" task; a read-aloud grade needs one made against the item's text.`);
+	if (evidence.locale !== item.locale) return unscorable("locale_mismatch", `The assessment was made for locale "${evidence.locale}", and the item is read in "${item.locale}". Pronunciation is assessed against one locale's speech.`);
+	if (evidence.referenceText !== item.referenceText) return unscorable("reference_mismatch", "The assessment was made against a different text from the one this item asks the learner to read.");
+	if (evidence.recordingKey !== recording.key) return unscorable("recording_mismatch", `The assessment was made for recording "${String(evidence.recordingKey)}", and this response submitted "${recording.key}".`);
+	if (evidence.assessor.kind === "ai" && options.allowAiAssessor !== true) return unscorable("assessor_not_accepted", "The assessment was produced by a generative model. Pass `allowAiAssessor: true` to accept that as measurement evidence.");
+	if (evidence.status === "no_speech") return unscorable("no_speech", "The assessor heard no speech in this recording.");
+	if (voicedMs < minVoicedMs) return unscorable("insufficient_voiced_time", `The recording holds ${voicedMs} ms of voiced time, and the policy asks for at least ${minVoicedMs} ms.`);
+	const words = spokenWordCount(evidence);
+	if (words > 0 && (voicedMs === 0 || words / (voicedMs / 1e3) > maxWordsPerSecond)) return unscorable("implausible_speech_rate", `The assessment claims ${words} word(s) in ${voicedMs} ms of voiced time, above the ${maxWordsPerSecond} word(s) per second the policy allows.`);
+	const weighed = item.scoring.dimensions.filter((dimension) => dimension.weight > 0);
+	const missing = weighed.find((dimension) => evidence.scores[dimension.name] === void 0);
+	if (missing !== void 0) return unscorable("missing_dimension", `The item weighs "${missing.name}", and the assessment carries no ${missing.name} score. An absent score is not a 0.`);
+	const graded = gradeFromRubric(weighed.map((dimension) => ({
+		name: dimension.name,
+		score: evidence.scores[dimension.name],
+		maxScore: ASSESSMENT_SCALE,
+		weight: dimension.weight
+	})), item, rounding !== void 0 ? { rounding } : {});
+	if ("unscorable" in graded) return unscorable("invalid_assessment", `No weighted total could be computed from the assessment's scores: ${graded.reason}`);
+	const details = [];
+	for (const entry of alignValidated(item, evidence)) {
+		if (entry.itemId === void 0) continue;
+		details.push({
+			itemId: entry.itemId,
+			outcome: entry.state === "correct" ? "correct" : entry.state === "mispronounced" ? "incorrect" : "incorrect-omission",
+			learnerResponse: entry.heard,
+			correctResponse: entry.reference,
+			weight: 1,
+			...scoreOf(entry)
+		});
+	}
+	return {
+		...graded,
+		feedback: selectFeedback(item, graded.passed),
+		details,
+		grader: { ...evidence.assessor }
+	};
+}
+/** The item's reference words, as `dictationReferenceWords` numbers them. */
+function referenceWordsOf(data) {
+	return dictationReferenceWords({ transcript: data.referenceText })[0];
+}
+//#endregion
+//#region src/scoring/speech/wav.ts
+/** `RIFF` + the file size + `WAVE`, before the first chunk. */
+const HEADER_BYTES = 12;
+/** A chunk's four-character id and its little-endian size. */
+const CHUNK_HEADER_BYTES = 8;
+/** `audioFormat`, `channels`, `sampleRate`, `byteRate`, `blockAlign`, `bitsPerSample`. */
+const FMT_MIN_BYTES = 16;
+/** WAVE_FORMAT_EXTENSIBLE carries a `SubFormat` GUID; the chunk is this long with it. */
+const EXTENSIBLE_BYTES = 40;
+/** Where the `SubFormat` GUID starts inside the `fmt ` body. Its first two bytes are the real format. */
+const SUBFORMAT_OFFSET = 24;
+/** Uncompressed PCM, as `audioFormat` and as the first two bytes of a `SubFormat`. */
+const FORMAT_PCM = 1;
+/** WAVE_FORMAT_EXTENSIBLE: the real format is in the `SubFormat` GUID. */
+const FORMAT_EXTENSIBLE = 65534;
+/** The only sample width read. */
+const BITS_PER_SAMPLE = 16;
+const BYTES_PER_SAMPLE = 2;
+/** Full scale for a 16-bit sample: `-32768` is the loudest a sample can be. */
+const FULL_SCALE = 32768;
+/** A value named in an error message, without serialising the object it came from. */
+function describeValue(value) {
+	return typeof value === "number" ? String(value) : `of type ${typeof value}`;
+}
+/** The four-character chunk id at `offset`. */
+function tagAt(view, offset) {
+	return String.fromCharCode(view.getUint8(offset), view.getUint8(offset + 1), view.getUint8(offset + 2), view.getUint8(offset + 3));
+}
+/**
+* The `fmt ` chunk when it describes 16-bit PCM this reader can measure, and
+* `undefined` for anything else — a compressed stream, 8- or 24-bit samples, a
+* channel count or sample rate of 0, a `blockAlign` that disagrees with them,
+* or a chunk too short to say.
+*/
+function formatAt(view, body, size) {
+	if (size < FMT_MIN_BYTES || body + FMT_MIN_BYTES > view.byteLength) return;
+	const audioFormat = view.getUint16(body, true);
+	const channels = view.getUint16(body + 2, true);
+	const sampleRate = view.getUint32(body + 4, true);
+	const blockAlign = view.getUint16(body + 12, true);
+	const bitsPerSample = view.getUint16(body + 14, true);
+	if (!(audioFormat === FORMAT_PCM || audioFormat === FORMAT_EXTENSIBLE && size >= EXTENSIBLE_BYTES && body + EXTENSIBLE_BYTES <= view.byteLength && view.getUint16(body + SUBFORMAT_OFFSET, true) === FORMAT_PCM) || bitsPerSample !== BITS_PER_SAMPLE || channels < 1 || sampleRate < 1 || blockAlign !== channels * BYTES_PER_SAMPLE) return;
+	return {
+		channels,
+		sampleRate,
+		blockAlign
+	};
+}
+/**
+* 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.
+*/
+function inspectWav(bytes, policy) {
+	if (!(bytes instanceof Uint8Array)) throw new TypeError("inspectWav reads a recording's bytes: pass a Uint8Array of the WAV file.");
+	const silenceDbfs = policy?.silenceDbfs;
+	if (typeof silenceDbfs !== "number" || !Number.isFinite(silenceDbfs) || silenceDbfs > 0) throw new RangeError(`Invalid inspection policy (silenceDbfs ${describeValue(silenceDbfs)}): expected a finite number of dBFS at or below 0, full scale being 0.`);
+	const frameMs = policy?.frameMs;
+	if (typeof frameMs !== "number" || !Number.isFinite(frameMs) || frameMs <= 0) throw new RangeError(`Invalid inspection policy (frameMs ${describeValue(frameMs)}): expected a finite window length in milliseconds, above 0.`);
+	const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+	if (view.byteLength < HEADER_BYTES || tagAt(view, 0) !== "RIFF" || tagAt(view, 8) !== "WAVE") return {
+		valid: false,
+		reason: "not_wav"
+	};
+	let format;
+	let data;
+	let offset = HEADER_BYTES;
+	while (offset + CHUNK_HEADER_BYTES <= view.byteLength) {
+		const id = tagAt(view, offset);
+		const size = view.getUint32(offset + 4, true);
+		const body = offset + CHUNK_HEADER_BYTES;
+		if (id === "fmt ") {
+			format = formatAt(view, body, size);
+			if (format === void 0) return {
+				valid: false,
+				reason: "unsupported_encoding"
+			};
+		} else if (id === "data") {
+			if (format === void 0) return {
+				valid: false,
+				reason: "not_wav"
+			};
+			data = {
+				offset: body,
+				declared: size
+			};
+			break;
+		}
+		offset = body + size + size % 2;
+	}
+	if (format === void 0) return {
+		valid: false,
+		reason: "not_wav"
+	};
+	if (data === void 0 || data.declared > view.byteLength - data.offset) return {
+		valid: false,
+		reason: "truncated"
+	};
+	const { channels, sampleRate, blockAlign } = format;
+	const frames = Math.floor(data.declared / blockAlign);
+	const samples = frames * channels;
+	let peak = 0;
+	for (let index = 0; index < samples; index += 1) {
+		const magnitude = Math.abs(view.getInt16(data.offset + index * BYTES_PER_SAMPLE, true));
+		if (magnitude > peak) peak = magnitude;
+	}
+	const windowFrames = Math.max(1, Math.round(sampleRate * frameMs / 1e3));
+	let voicedMs = 0;
+	for (let start = 0; start < frames; start += windowFrames) {
+		const windowLength = Math.min(windowFrames, frames - start);
+		const windowSamples = windowLength * channels;
+		let sum = 0;
+		for (let index = 0; index < windowSamples; index += 1) {
+			const sample = view.getInt16(data.offset + (start * channels + index) * BYTES_PER_SAMPLE, true) / FULL_SCALE;
+			sum += sample * sample;
+		}
+		const rms = Math.sqrt(sum / windowSamples);
+		if ((rms > 0 ? 20 * Math.log10(rms) : Number.NEGATIVE_INFINITY) >= silenceDbfs) voicedMs += windowLength * 1e3 / sampleRate;
+	}
+	const durationMs = frames * 1e3 / sampleRate;
+	return {
+		valid: true,
+		durationMs,
+		sampleRate,
+		channels,
+		bitsPerSample: BITS_PER_SAMPLE,
+		peakDbfs: peak === 0 ? Number.NEGATIVE_INFINITY : 20 * Math.log10(peak / FULL_SCALE),
+		voicedMs: Math.min(voicedMs, durationMs)
+	};
+}
+//#endregion
+//#region src/scoring/unscorable.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.
+*/
+function outcomeFromUnscorable(result) {
+	return {
+		status: "unscorable",
+		reason: result.reason,
+		maxScore: 1,
+		code: result.code
+	};
+}
+//#endregion
+//#region src/scoring/index.ts
+/**
+* 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".
+*/
+function score(activityType, activityData, learnerResponse, options) {
+	const rounding = roundingPolicyOf(options?.rounding);
+	const descriptor = getActivityTypeDescriptor(activityType);
+	if (descriptor === void 0) throw new UnknownActivityTypeError(String(activityType));
+	if (descriptor.scoring.kind === "deferred") throw new DeferredScoringError(descriptor.type);
+	if (isRedacted(activityData)) throw new RedactedScoringError(descriptor.type);
+	const result = descriptor.scoring.score(activityData, learnerResponse);
+	if (!Number.isFinite(result.score)) throw new RedactedScoringError(descriptor.type);
+	const passed = computePassThreshold(activityData, result.score, rounding);
+	return {
+		...result,
+		passed,
+		feedback: result.feedback ?? selectFeedback(activityData, passed)
+	};
+}
+/**
+* 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.
+*/
+function evaluate(data, response, options) {
+	const rounding = roundingPolicyOf(options?.rounding);
+	const scoring = options?.scoring;
+	const rules = resolveItemScoringPolicy(scoring);
+	const outcome = evaluateAnswer(data, response, rounding);
+	if (scoring === void 0 || scoring === null || outcome.status !== "scored") return outcome;
+	return costed(data, outcome, [{
+		response,
+		outcome
+	}], rules, rounding).outcome;
+}
+/** What `evaluate` does with no policy: the answer's own outcome. */
+function evaluateAnswer(data, response, rounding) {
+	const type = data.type;
+	const descriptor = typeof type === "string" ? getActivityTypeDescriptor(type) : void 0;
+	if (descriptor === void 0) return {
+		status: "unscorable",
+		reason: `Activity type "${String(type)}" is not registered`,
+		maxScore: 1
+	};
+	if (descriptor.scoring.kind === "deferred") {
+		const partial = descriptor.scoring.partial?.(data, response);
+		return {
+			status: "deferred",
+			reason: descriptor.scoring.reason,
+			maxScore: 1,
+			...partial !== void 0 ? { partial } : {}
+		};
+	}
+	if (isRedacted(data)) return {
+		status: "unscorable",
+		reason: "Activity data is redacted (no answer key), so it cannot be scored on the client. Score against the full data server-side.",
+		maxScore: 1
+	};
+	const result = descriptor.scoring.score(data, response);
+	if (!Number.isFinite(result.score)) return {
+		status: "unscorable",
+		reason: `Scoring "${descriptor.type}" produced a non-finite score; the activity data is incomplete.`,
+		maxScore: result.maxScore
+	};
+	const passed = computePassThreshold(data, result.score, rounding);
+	return {
+		status: "scored",
+		score: result.score,
+		maxScore: result.maxScore,
+		passed,
+		feedback: result.feedback ?? selectFeedback(data, passed),
+		details: result.details
+	};
+}
+/**
+* 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.
+*/
+function evaluateTries(data, responses, options) {
+	const rounding = roundingPolicyOf(options?.rounding);
+	const rules = resolveItemScoringPolicy(options?.scoring);
+	if (responses.length === 0) return {
+		outcome: {
+			status: "deferred",
+			reason: "no_response_recorded",
+			maxScore: 1
+		},
+		counted: null,
+		tries: []
+	};
+	const graded = responses.slice(0, 1 + rules.retries).map((response) => ({
+		response,
+		outcome: evaluateAnswer(data, response, rounding)
+	}));
+	const opening = graded[0].outcome;
+	if (opening.status !== "scored") return {
+		outcome: opening,
+		counted: null,
+		tries: []
+	};
+	if ((options?.scoring === void 0 || options.scoring === null) && !isGradeInRange(opening.score, opening.maxScore)) return {
+		outcome: opening,
+		counted: 0,
+		tries: []
+	};
+	return costed(data, opening, graded, rules, rounding);
+}
+/**
+* Charges each try what it cost and picks the one that counts. A try whose
+* numbers cannot be a grade — a registered scorer out of contract — has
+* nothing to charge a cost to, and leaves the question unscorable rather than
+* scored on the other tries.
+*/
+function costed(data, opening, graded, rules, rounding) {
+	const scored = [];
+	for (const [index, one] of graded.entries()) {
+		if (one.outcome.status !== "scored" || !isGradeInRange(one.outcome.score, one.outcome.maxScore)) return {
+			outcome: {
+				status: "unscorable",
+				reason: `Try ${index + 1} has no grade to charge a cost to, so the question has none under this scoring policy.`,
+				maxScore: opening.maxScore
+			},
+			counted: null,
+			tries: []
+		};
+		scored.push(one.outcome);
+	}
+	const result = scoreTries(scored.map((outcome, index) => ({
+		score: outcome.score,
+		maxScore: outcome.maxScore,
+		hintsRevealed: (graded[index]?.response)?.hintsRevealed
+	})), rules);
+	const chosen = scored[result.counted];
+	return {
+		outcome: result.score === chosen.score ? chosen : {
+			...chosen,
+			score: result.score,
+			passed: computePassThreshold(data, result.score, rounding)
+		},
+		counted: result.counted,
+		tries: result.tries
+	};
+}
+//#endregion
+export { validateItemScoringPolicy as C, scoreTries as S, gte as _, inspectWav as a, ITEM_SCORING_MAX_RETRIES as b, validateSpeechAssessment as c, gradeFromRubric as d, hasGrade as f, classifyBand as g, computePassThreshold as h, outcomeFromUnscorable as i, diffDictationChars as l, DEFAULT_PASS_THRESHOLD as m, evaluateTries as n, gradeReadAloud as o, outcomeFromGrade as p, score as r, alignReadAloud as s, evaluate as t, composeAssessmentScore as u, roundGrade as v, isGradeInRange as w, resolveItemScoringPolicy as x, DEFAULT_ITEM_SCORING_POLICY as y };
+
+//# sourceMappingURL=scoring-BZqUkuDF.js.map