@intellectif/lk-core 1.2.0 → 1.4.0

package/dist/scoring-B2_HEhMT.cjs

@@ -0,0 +1,1748 @@
+const require_registry = require("./registry-DVi0LR_i.cjs");
+let zod_v4 = require("zod/v4");
+zod_v4 = require_registry.__toESM(zod_v4, 1);
+//#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 require_registry.alignSequences(referencePoints, attemptPoints).map(({ step, referenceIndex, attemptIndex }) => {
+		if (step === require_registry.STEP.missing) return {
+			op: "missing",
+			reference: referencePoints[referenceIndex],
+			attempt: ""
+		};
+		if (step === require_registry.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 = require_registry.normalizeDictationText(word.text);
+		if (normalized === "") continue;
+		const inserted = word.error === "insertion";
+		for (const text of normalized.split(" ")) {
+			length += require_registry.codePointLength(text) + (length === 0 ? 0 : 1);
+			if (!inserted && length <= require_registry.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 = zod_v4.number().min(0).max(100);
+/** A confidence, 0..1. */
+const Confidence = zod_v4.number().min(0).max(1);
+/** A time from the start of the recording, or a length of time, in milliseconds. */
+const Milliseconds = zod_v4.number().min(0);
+const PhonemeCandidateSchema = zod_v4.strictObject({
+	symbol: require_registry.maxUnits(zod_v4.string().min(1), 16),
+	score: Score
+});
+const PhonemeSchema = zod_v4.strictObject({
+	symbol: require_registry.maxUnits(zod_v4.string().min(1), 16).optional(),
+	accuracy: Score.optional(),
+	startMs: Milliseconds.optional(),
+	durationMs: Milliseconds.optional(),
+	heardAs: zod_v4.array(PhonemeCandidateSchema).max(10).optional()
+});
+const SyllableSchema = zod_v4.strictObject({
+	text: require_registry.maxUnits(zod_v4.string().min(1), 64),
+	grapheme: require_registry.maxUnits(zod_v4.string(), 64).optional(),
+	accuracy: Score.optional(),
+	startMs: Milliseconds.optional(),
+	durationMs: Milliseconds.optional()
+});
+const WordSchema = zod_v4.strictObject({
+	text: require_registry.maxUnits(zod_v4.string().min(1), 200),
+	accuracy: Score.optional(),
+	error: zod_v4.enum([
+		"none",
+		"mispronunciation",
+		"omission",
+		"insertion"
+	]),
+	vendorError: require_registry.maxUnits(zod_v4.string(), 64).optional(),
+	startMs: Milliseconds.optional(),
+	durationMs: Milliseconds.optional(),
+	syllables: zod_v4.array(SyllableSchema).max(50).optional(),
+	phonemes: zod_v4.array(PhonemeSchema).max(50).optional(),
+	breaks: zod_v4.strictObject({
+		unexpected: Confidence.optional(),
+		missing: Confidence.optional()
+	}).optional()
+});
+const AssessorSchema = zod_v4.strictObject({
+	kind: zod_v4.enum([
+		"auto",
+		"ai",
+		"human"
+	]),
+	id: require_registry.maxUnits(zod_v4.string(), 256).optional(),
+	model: require_registry.maxUnits(zod_v4.string(), 256).optional(),
+	promptHash: require_registry.maxUnits(zod_v4.string(), 256).optional()
+});
+const SpeechAssessmentSchema = zod_v4.strictObject({
+	assessmentVersion: zod_v4.literal("1.0"),
+	status: zod_v4.enum(["assessed", "no_speech"]),
+	task: zod_v4.enum(["scripted", "unscripted"]),
+	locale: zod_v4.string().regex(require_registry.CANONICAL_LOCALE_RE),
+	referenceText: require_registry.maxUnits(zod_v4.string(), 8e3).optional(),
+	recordingKey: require_registry.maxUnits(zod_v4.string().min(1), 1024).optional(),
+	assessor: AssessorSchema,
+	scale: zod_v4.literal(100),
+	scores: zod_v4.strictObject({
+		accuracy: Score.optional(),
+		fluency: Score.optional(),
+		completeness: Score.optional(),
+		prosody: Score.optional(),
+		overall: Score.optional()
+	}),
+	recognizedText: require_registry.maxUnits(zod_v4.string(), 8e3).optional(),
+	miscue: zod_v4.enum(["assessor", "none"]),
+	phonemeAlphabet: zod_v4.enum(["ipa", "sapi"]).optional(),
+	words: zod_v4.array(WordSchema).max(require_registry.SPEECH_ASSESSMENT_MAX_WORDS),
+	prosody: zod_v4.strictObject({ monotoneConfidence: Confidence.optional() }).optional(),
+	signal: zod_v4.strictObject({ snrDb: zod_v4.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 > require_registry.SPEECH_ASSESSMENT_MAX_TEXT_LENGTH) return [{
+		path: ["words"],
+		message: `The words of an assessment carry ${raw} characters between them, and at most ${require_registry.SPEECH_ASSESSMENT_MAX_TEXT_LENGTH} can be aligned against the text of an item.`,
+		code: "too_big"
+	}];
+	const normalized = heardTokens(words).length;
+	if (normalized > require_registry.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 ${require_registry.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 = require_registry.dictationReferenceWords({ transcript: data.referenceText })[0];
+	const heard = heardTokens(assessment.words).tokens;
+	const entries = [];
+	for (const { step, referenceIndex, attemptIndex } of require_registry.alignSequences(reference.map((word) => word.word), heard.map((token) => token.text))) {
+		if (step === require_registry.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 === require_registry.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: require_registry.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 require_registry.countWords(recognized);
+	return require_registry.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 = require_registry.ReadAloudDataSchema.safeParse(data);
+	if (!parsed.success) throw new require_registry.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 require_registry.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 require_registry.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 = require_registry.getActivityTypeDescriptor(activityType);
+	if (descriptor === void 0) throw new require_registry.UnknownActivityTypeError(String(activityType));
+	if (descriptor.scoring.kind === "deferred") throw new require_registry.DeferredScoringError(descriptor.type);
+	if (isRedacted(activityData)) throw new require_registry.RedactedScoringError(descriptor.type);
+	const result = descriptor.scoring.score(activityData, learnerResponse);
+	if (!Number.isFinite(result.score)) throw new require_registry.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" ? require_registry.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
+Object.defineProperty(exports, "DEFAULT_ITEM_SCORING_POLICY", {
+	enumerable: true,
+	get: function() {
+		return DEFAULT_ITEM_SCORING_POLICY;
+	}
+});
+Object.defineProperty(exports, "DEFAULT_PASS_THRESHOLD", {
+	enumerable: true,
+	get: function() {
+		return DEFAULT_PASS_THRESHOLD;
+	}
+});
+Object.defineProperty(exports, "ITEM_SCORING_MAX_RETRIES", {
+	enumerable: true,
+	get: function() {
+		return ITEM_SCORING_MAX_RETRIES;
+	}
+});
+Object.defineProperty(exports, "alignReadAloud", {
+	enumerable: true,
+	get: function() {
+		return alignReadAloud;
+	}
+});
+Object.defineProperty(exports, "classifyBand", {
+	enumerable: true,
+	get: function() {
+		return classifyBand;
+	}
+});
+Object.defineProperty(exports, "composeAssessmentScore", {
+	enumerable: true,
+	get: function() {
+		return composeAssessmentScore;
+	}
+});
+Object.defineProperty(exports, "computePassThreshold", {
+	enumerable: true,
+	get: function() {
+		return computePassThreshold;
+	}
+});
+Object.defineProperty(exports, "diffDictationChars", {
+	enumerable: true,
+	get: function() {
+		return diffDictationChars;
+	}
+});
+Object.defineProperty(exports, "evaluate", {
+	enumerable: true,
+	get: function() {
+		return evaluate;
+	}
+});
+Object.defineProperty(exports, "evaluateTries", {
+	enumerable: true,
+	get: function() {
+		return evaluateTries;
+	}
+});
+Object.defineProperty(exports, "gradeFromRubric", {
+	enumerable: true,
+	get: function() {
+		return gradeFromRubric;
+	}
+});
+Object.defineProperty(exports, "gradeReadAloud", {
+	enumerable: true,
+	get: function() {
+		return gradeReadAloud;
+	}
+});
+Object.defineProperty(exports, "gte", {
+	enumerable: true,
+	get: function() {
+		return gte;
+	}
+});
+Object.defineProperty(exports, "hasGrade", {
+	enumerable: true,
+	get: function() {
+		return hasGrade;
+	}
+});
+Object.defineProperty(exports, "inspectWav", {
+	enumerable: true,
+	get: function() {
+		return inspectWav;
+	}
+});
+Object.defineProperty(exports, "isGradeInRange", {
+	enumerable: true,
+	get: function() {
+		return isGradeInRange;
+	}
+});
+Object.defineProperty(exports, "outcomeFromGrade", {
+	enumerable: true,
+	get: function() {
+		return outcomeFromGrade;
+	}
+});
+Object.defineProperty(exports, "outcomeFromUnscorable", {
+	enumerable: true,
+	get: function() {
+		return outcomeFromUnscorable;
+	}
+});
+Object.defineProperty(exports, "resolveItemScoringPolicy", {
+	enumerable: true,
+	get: function() {
+		return resolveItemScoringPolicy;
+	}
+});
+Object.defineProperty(exports, "roundGrade", {
+	enumerable: true,
+	get: function() {
+		return roundGrade;
+	}
+});
+Object.defineProperty(exports, "score", {
+	enumerable: true,
+	get: function() {
+		return score;
+	}
+});
+Object.defineProperty(exports, "scoreTries", {
+	enumerable: true,
+	get: function() {
+		return scoreTries;
+	}
+});
+Object.defineProperty(exports, "validateItemScoringPolicy", {
+	enumerable: true,
+	get: function() {
+		return validateItemScoringPolicy;
+	}
+});
+Object.defineProperty(exports, "validateSpeechAssessment", {
+	enumerable: true,
+	get: function() {
+		return validateSpeechAssessment;
+	}
+});
+
+//# sourceMappingURL=scoring-B2_HEhMT.cjs.map