@intellectif/lk-core 0.13.1 → 0.14.0

package/dist/chunk-RTIR6R2U.js

@@ -0,0 +1,1034 @@
+import {
+  ActivitySchemaError,
+  CANONICAL_LOCALE_RE,
+  DeferredScoringError,
+  ReadAloudDataSchema,
+  RedactedScoringError,
+  SPEECH_ASSESSMENT_MAX_TEXT_LENGTH,
+  SPEECH_ASSESSMENT_MAX_WORDS,
+  STEP,
+  UnknownActivityTypeError,
+  alignSequences,
+  codePointLength,
+  countWords,
+  dictationReferenceWords,
+  getActivityTypeDescriptor,
+  normalizeDictationText
+} from "./chunk-6RND47QE.js";
+
+// src/is-redacted.ts
+function isRedacted(data) {
+  return typeof data === "object" && data !== null && data.redacted === true;
+}
+
+// src/scoring/rounding.ts
+var ROUNDING_MODES = ["half-up", "half-even", "floor", "ceil"];
+var MAX_ROUNDING_DP = 15;
+function roundingPolicyOf(value) {
+  if (value === void 0 || value === null) {
+    return void 0;
+  }
+  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 };
+}
+var EPSILON = 1e-9;
+var TIE_TOLERANCE = 1e-6;
+function scaled(value, dp) {
+  return value * 10 ** dp;
+}
+function noNegZero(value) {
+  return Object.is(value, -0) ? 0 : value;
+}
+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 - 0.5) > TIE_TOLERANCE) {
+        return noNegZero(halfAway(raw) / factor);
+      }
+      const even = floored % 2 === 0 ? floored : floored + 1;
+      return noNegZero(even / factor);
+    }
+    default:
+      return noNegZero(halfAway(raw) / factor);
+  }
+}
+function halfAway(raw) {
+  const nudged = raw >= 0 ? raw + EPSILON : raw - EPSILON;
+  return raw >= 0 ? Math.round(nudged) : -Math.round(-nudged);
+}
+function gte(value, threshold, policy) {
+  return roundGrade(value, policy) >= roundGrade(threshold, policy) - EPSILON;
+}
+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;
+}
+
+// src/scoring/pass-threshold.ts
+var DEFAULT_PASS_THRESHOLD = 0.7;
+function computePassThreshold(activityData, score2, rounding) {
+  const threshold = activityData.passThreshold ?? DEFAULT_PASS_THRESHOLD;
+  return rounding === void 0 ? score2 >= threshold : gte(score2, threshold, rounding);
+}
+function selectFeedback(activityData, passed) {
+  const feedback = activityData.feedback;
+  if (feedback === void 0) {
+    return null;
+  }
+  return (passed ? feedback.correct : feedback.incorrect) ?? null;
+}
+
+// src/grading.ts
+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"
+  );
+  const ratioOf = (criterion) => criterion.score / (criterion.maxScore ?? 1);
+  const EPSILON2 = 1e-9;
+  const outOfRange = scoreable.find(
+    (criterion) => ratioOf(criterion) < -EPSILON2 || ratioOf(criterion) > 1 + EPSILON2
+  );
+  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\u2013100 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 weighted = scoreable.reduce(
+    (sum, criterion) => sum + ratioOf(criterion) * (criterion.weight ?? 1),
+    0
+  );
+  const rawScore = weighted / totalWeight;
+  if (!Number.isFinite(rawScore)) {
+    return {
+      unscorable: true,
+      reason: "The weighted total is not a finite number, so no grade can be produced."
+    };
+  }
+  const score2 = Math.min(1, Math.max(0, rawScore));
+  const reaches = (threshold) => rounding === void 0 ? score2 >= threshold : gte(score2, threshold, rounding);
+  const passed = options.passThreshold !== void 0 ? reaches(options.passThreshold) : activityData !== void 0 ? computePassThreshold(activityData, score2, rounding) : reaches(0.7);
+  return {
+    score: score2,
+    maxScore: 1,
+    passed,
+    feedback: options.feedback ?? null,
+    criteria: [...criteria]
+  };
+}
+function outcomeFromGrade(grade) {
+  return {
+    status: "graded",
+    grade,
+    score: grade.score,
+    maxScore: grade.maxScore,
+    passed: grade.passed,
+    feedback: grade.feedback
+  };
+}
+function hasGrade(outcome) {
+  return outcome.status === "scored" || outcome.status === "graded";
+}
+
+// src/scoring/compose.ts
+function earned(item) {
+  const { outcome } = item;
+  if (hasGrade(outcome)) {
+    const max = outcome.maxScore > 0 ? outcome.maxScore : 1;
+    return { state: "graded", points: outcome.score / max * item.points };
+  }
+  if (outcome.status === "deferred") {
+    return { state: "pending" };
+  }
+  return { state: "unscorable" };
+}
+function composeAssessmentScore(sections, policy) {
+  const pendingAll = [];
+  const unscorableAll = [];
+  const partials = sections.map((section) => {
+    let earnedPoints = 0;
+    let gradedMaxPoints = 0;
+    let maxPoints = 0;
+    const pendingSlotIds = [];
+    const unscorableSlotIds = [];
+    for (const item of section.items) {
+      maxPoints += item.points;
+      const contribution = earned(item);
+      if (contribution.state === "pending") {
+        pendingSlotIds.push(item.slotId);
+        pendingAll.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,
+      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,
+    // A section with nothing graded yet cannot be said to have failed.
+    passed: partial.appliedThreshold === null || partial.gradedMaxPoints === 0 ? true : gte(partial.score, partial.appliedThreshold, policy.rounding),
+    appliedThreshold: partial.appliedThreshold,
+    pendingSlotIds: partial.pendingSlotIds,
+    unscorableSlotIds: partial.unscorableSlotIds
+  }));
+  const weightedRaw = scored.reduce(
+    (sum, section) => sum + section.score * section.normalizedWeight,
+    0
+  );
+  const score2 = roundGrade(weightedRaw, policy.rounding);
+  const status = pendingAll.length > 0 ? "provisional" : "final";
+  if (status === "provisional") {
+    return {
+      sections: scored,
+      score: score2,
+      passed: null,
+      passFailureReason: null,
+      status,
+      pendingSlotIds: pendingAll,
+      unscorableSlotIds: unscorableAll
+    };
+  }
+  if (scored.every((section) => section.gradedMaxPoints === 0)) {
+    return {
+      sections: scored,
+      score: score2,
+      passed: null,
+      passFailureReason: null,
+      status,
+      pendingSlotIds: pendingAll,
+      unscorableSlotIds: unscorableAll
+    };
+  }
+  const overallOk = gte(score2, policy.passThreshold, policy.rounding);
+  const sectionsOk = scored.every((section) => section.passed);
+  const passed = overallOk && sectionsOk;
+  const passFailureReason = passed ? null : !overallOk && !sectionsOk ? "both" : overallOk ? "section_below_threshold" : "overall_below_threshold";
+  return {
+    sections: scored,
+    score: score2,
+    passed,
+    passFailureReason,
+    status,
+    pendingSlotIds: pendingAll,
+    unscorableSlotIds: unscorableAll
+  };
+}
+
+// src/scoring/dictation/chars.ts
+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
+      };
+    }
+  );
+}
+
+// src/scoring/speech/assessment.ts
+import { z } from "zod/v4";
+
+// src/scoring/speech/tokens.ts
+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 };
+}
+
+// src/scoring/speech/assessment.ts
+var Score = z.number().min(0).max(100);
+var Confidence = z.number().min(0).max(1);
+var Milliseconds = z.number().min(0);
+var PhonemeCandidateSchema = z.strictObject({
+  symbol: z.string().min(1).max(16),
+  score: Score
+});
+var PhonemeSchema = z.strictObject({
+  symbol: z.string().min(1).max(16).optional(),
+  accuracy: Score.optional(),
+  startMs: Milliseconds.optional(),
+  durationMs: Milliseconds.optional(),
+  heardAs: z.array(PhonemeCandidateSchema).max(10).optional()
+});
+var SyllableSchema = z.strictObject({
+  text: z.string().min(1).max(64),
+  grapheme: z.string().max(64).optional(),
+  accuracy: Score.optional(),
+  startMs: Milliseconds.optional(),
+  durationMs: Milliseconds.optional()
+});
+var WordSchema = z.strictObject({
+  text: z.string().min(1).max(200),
+  accuracy: Score.optional(),
+  error: z.enum(["none", "mispronunciation", "omission", "insertion"]),
+  vendorError: z.string().max(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()
+});
+var AssessorSchema = z.strictObject({
+  kind: z.enum(["auto", "ai", "human"]),
+  id: z.string().max(256).optional(),
+  model: z.string().max(256).optional(),
+  promptHash: z.string().max(256).optional()
+});
+var 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: z.string().max(8e3).optional(),
+  recordingKey: z.string().min(1).max(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: z.string().max(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()
+});
+var isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+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)
+    );
+  });
+}
+function rawTextLength(words) {
+  let total = 0;
+  for (const word of words) {
+    total += word.text.length;
+  }
+  return total;
+}
+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 [];
+}
+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;
+}
+function describeValidationError(error) {
+  return error.path.length === 0 ? error.message : `${error.path.join(".")}: ${error.message}`;
+}
+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 };
+}
+
+// src/scoring/speech/align.ts
+function accuracyOf(word) {
+  return word.accuracy !== void 0 ? { accuracy: word.accuracy } : {};
+}
+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);
+}
+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 token2 = heard[attemptIndex];
+      entries.push({
+        reference: "",
+        heard: token2.text,
+        state: "inserted",
+        ...accuracyOf(assessment.words[token2.wordIndex]),
+        wordIndex: token2.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,
+      // An omitted word was not read: whatever text the assessor carried for it
+      // describes the reference, not the learner.
+      heard: state === "omitted" ? "" : token.text,
+      state,
+      ...accuracyOf(word),
+      wordIndex: token.wordIndex
+    });
+  }
+  placeInsertions(assessment, entries);
+  return entries;
+}
+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";
+}
+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: "",
+      // Every insertion is accounted for, including one whose text normalises
+      // to nothing: a reader of `wordIndex` must find each word it looks for.
+      heard: normalizeDictationText(word.text),
+      state: "inserted",
+      ...accuracyOf(word),
+      wordIndex
+    });
+  });
+}
+
+// src/scoring/speech/grade.ts
+var MEASUREMENT_TOLERANCE = 1e-6;
+var ASSESSMENT_SCALE = 100;
+function describeValue(value) {
+  return typeof value === "number" ? String(value) : `of type ${typeof value}`;
+}
+function readResponseRecording(value) {
+  if (typeof value !== "object" || value === null) {
+    return void 0;
+  }
+  const { type, recording } = value;
+  if (type !== "read-aloud") {
+    return void 0;
+  }
+  if (recording === null) {
+    return { recording: null };
+  }
+  if (typeof recording !== "object") {
+    return void 0;
+  }
+  const { key, mimeType } = recording;
+  if (typeof key !== "string" || key === "" || typeof mimeType !== "string") {
+    return void 0;
+  }
+  return { recording: { key, mimeType } };
+}
+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(" ")
+  );
+}
+function scoreOf(entry) {
+  if (entry.state === "omitted") {
+    return { score: 0 };
+  }
+  return entry.accuracy !== void 0 ? { score: entry.accuracy / ASSESSMENT_SCALE } : {};
+}
+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(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(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: [],
+      // Every word of the text, unread. A blank is graded from the item alone:
+      // there is no assessment to read, and no grader to credit.
+      details: referenceWordsOf(item).map(({ itemId, word }) => ({
+        itemId,
+        correct: false,
+        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(durationMs)}, voicedMs ${describeValue(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 criteria = weighed.map((dimension) => ({
+    name: dimension.name,
+    score: evidence.scores[dimension.name],
+    maxScore: ASSESSMENT_SCALE,
+    weight: dimension.weight
+  }));
+  const graded = gradeFromRubric(criteria, 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,
+      correct: entry.state === "correct",
+      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,
+    // A copy, so a stored grade keeps who measured it even if the assessment
+    // object is later mutated or reused.
+    grader: { ...evidence.assessor }
+  };
+}
+function referenceWordsOf(data) {
+  return dictationReferenceWords({ transcript: data.referenceText })[0];
+}
+
+// src/scoring/speech/wav.ts
+var HEADER_BYTES = 12;
+var CHUNK_HEADER_BYTES = 8;
+var FMT_MIN_BYTES = 16;
+var EXTENSIBLE_BYTES = 40;
+var SUBFORMAT_OFFSET = 24;
+var FORMAT_PCM = 1;
+var FORMAT_EXTENSIBLE = 65534;
+var BITS_PER_SAMPLE = 16;
+var BYTES_PER_SAMPLE = 2;
+var FULL_SCALE = 32768;
+function describeValue2(value) {
+  return typeof value === "number" ? String(value) : `of type ${typeof value}`;
+}
+function tagAt(view, offset) {
+  return String.fromCharCode(
+    view.getUint8(offset),
+    view.getUint8(offset + 1),
+    view.getUint8(offset + 2),
+    view.getUint8(offset + 3)
+  );
+}
+function formatAt(view, body, size) {
+  if (size < FMT_MIN_BYTES || body + FMT_MIN_BYTES > view.byteLength) {
+    return void 0;
+  }
+  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);
+  const pcm = audioFormat === FORMAT_PCM || audioFormat === FORMAT_EXTENSIBLE && size >= EXTENSIBLE_BYTES && body + EXTENSIBLE_BYTES <= view.byteLength && view.getUint16(body + SUBFORMAT_OFFSET, true) === FORMAT_PCM;
+  if (!pcm || bitsPerSample !== BITS_PER_SAMPLE || channels < 1 || sampleRate < 1 || blockAlign !== channels * BYTES_PER_SAMPLE) {
+    return void 0;
+  }
+  return { channels, sampleRate, blockAlign };
+}
+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 ${describeValue2(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 ${describeValue2(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);
+    const db = rms > 0 ? 20 * Math.log10(rms) : Number.NEGATIVE_INFINITY;
+    if (db >= silenceDbfs) {
+      voicedMs += windowLength * 1e3 / sampleRate;
+    }
+  }
+  const durationMs = frames * 1e3 / sampleRate;
+  return {
+    valid: true,
+    durationMs,
+    sampleRate,
+    channels,
+    bitsPerSample: BITS_PER_SAMPLE,
+    // Digital silence has no level to report, and neither has a file with no
+    // frames: `-Infinity` says so, where a 0 would read as full scale.
+    peakDbfs: peak === 0 ? Number.NEGATIVE_INFINITY : 20 * Math.log10(peak / FULL_SCALE),
+    // Two measurements of one recording that must agree: the voiced time is
+    // added window by window, the duration is a single expression, and at a
+    // sample rate where a window is not a binary-exact number of milliseconds
+    // the sum can land a hair above the whole. `SpeechMeasurement` says voiced
+    // time is at most the duration and `gradeReadAloud` throws on a pair that
+    // is not, so the clamp makes the measurement consistent by construction
+    // rather than leaving a grading job to crash on the SDK's own output.
+    voicedMs: Math.min(voicedMs, durationMs)
+  };
+}
+
+// src/scoring/unscorable.ts
+function outcomeFromUnscorable(result) {
+  return { status: "unscorable", reason: result.reason, maxScore: 1, code: result.code };
+}
+
+// src/scoring/index.ts
+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) };
+}
+function evaluate(data, response, options) {
+  const rounding = roundingPolicyOf(options?.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
+  };
+}
+
+export {
+  roundGrade,
+  gte,
+  classifyBand,
+  DEFAULT_PASS_THRESHOLD,
+  computePassThreshold,
+  gradeFromRubric,
+  outcomeFromGrade,
+  hasGrade,
+  composeAssessmentScore,
+  diffDictationChars,
+  validateSpeechAssessment,
+  alignReadAloud,
+  gradeReadAloud,
+  inspectWav,
+  outcomeFromUnscorable,
+  score,
+  evaluate
+};
+//# sourceMappingURL=chunk-RTIR6R2U.js.map