@intellectif/lk-core 1.1.0 → 1.2.0

package/dist/{chunk-FBKTION6.js → chunk-QS7B42ZR.js}

@@ -289,7 +289,7 @@ var FOLDED = new Map(
     // TIBETAN MARK DELIMITER TSHEG BSTAR
     [65374, cp(12316)]
     // FULLWIDTH TILDE, which a Japanese keyboard types for the WAVE DASH
-  ].map(([point, folded]) => [cp(point), folded])
+  ].map(([point, folded2]) => [cp(point), folded2])
 );
 var FOLDED_RE = new RegExp(`[${[...FOLDED.keys()].join("")}]`, "gu");
 var DRAWN_FORMAT_CHARACTERS = `${cp(1536)}-${cp(1541)}${cp(1757, 1807, 2192, 2193, 2274, 69821, 69837)}`;
@@ -660,10 +660,10 @@ var CARRIED_MARKS_RE = new RegExp(`^[ ${cp(1600)}]?(\\p{M}+)$`, "u");
 var SPACING_CHARACTER_RE = new RegExp(`[\\s${NEXT_LINE}]`, "u");
 var PUNCTUATION_CHARACTER_RE = /^\p{P}$/u;
 function foldCompatibility(character, offset, text) {
-  const folded = character.normalize("NFKC");
-  const carried = CARRIED_MARKS_RE.exec(folded);
+  const folded2 = character.normalize("NFKC");
+  const carried = CARRIED_MARKS_RE.exec(folded2);
   if (carried === null) {
-    return COMPATIBILITY_JAMO.get(folded) ?? folded;
+    return COMPATIBILITY_JAMO.get(folded2) ?? folded2;
   }
   return PUNCTUATION_CHARACTER_RE.test(character) || offset === 0 || SPACING_CHARACTER_RE.test(text.charAt(offset - 1)) ? character : carried[1];
 }
@@ -917,8 +917,8 @@ var NOTHING_TO_REVEAL = { forms: [], long: false, before: "none", after: "none"
 function stripForReveal(text) {
   return stripPunctuation(text.replace(DIGIT_SEPARATOR_RE, ""));
 }
-function readingOf(written, working) {
-  const writtenStripped = stripForReveal(written);
+function readingOf(written2, working) {
+  const writtenStripped = stripForReveal(written2);
   const workingStripped = stripForReveal(working);
   const source = writtenStripped === "" ? workingStripped : writtenStripped;
   if (source === "") {
@@ -928,7 +928,7 @@ function readingOf(written, working) {
   const { before, after } = phraseOf(source, long ? "none" : "visible");
   const forms = [
     writtenStripped,
-    spacePunctuation(written),
+    spacePunctuation(written2),
     workingStripped,
     spacePunctuation(working)
   ].map((form) => long ? form.replace(SPACE_BESIDE_UNSPACED_RE, "") : form);
@@ -945,13 +945,13 @@ function dictationNormalizer(tolerance) {
         if (isLongerThan(text, DICTATION_MAX_TRANSCRIPT_LENGTH)) {
           result = { tooLong: true, normalized: null, reveal: NOTHING_TO_REVEAL };
         } else {
-          const written = boundedPreStrip(text);
-          const working = workingText(text, compiled, written);
+          const written2 = boundedPreStrip(text);
+          const working = workingText(text, compiled, written2);
           const normalized = stripPunctuation(working.text);
           result = {
             tooLong: working.cut || isLongerThan(normalized, DICTATION_MAX_TRANSCRIPT_LENGTH),
             normalized,
-            reveal: readingOf(written.text, working.text)
+            reveal: readingOf(written2.text, working.text)
           };
         }
         measured.set(text, result);
@@ -1172,7 +1172,7 @@ function alignSequences(reference, attempt) {
 }
 function alignWords(reference, attempt) {
   const words = [];
-  let ordinal = 0;
+  let ordinal2 = 0;
   for (const { step, referenceIndex, attemptIndex } of alignSequences(reference, attempt)) {
     if (step === STEP.extra) {
       words.push({
@@ -1183,11 +1183,11 @@ function alignWords(reference, attempt) {
       });
       continue;
     }
-    ordinal += 1;
+    ordinal2 += 1;
     const referenceWord = reference[referenceIndex];
     if (step === STEP.missing) {
       words.push({
-        itemId: `w${ordinal}`,
+        itemId: `w${ordinal2}`,
         reference: referenceWord,
         attempt: "",
         similarity: 0,
@@ -1197,7 +1197,7 @@ function alignWords(reference, attempt) {
     }
     const attemptWord = attempt[attemptIndex];
     words.push({
-      itemId: `w${ordinal}`,
+      itemId: `w${ordinal2}`,
       reference: referenceWord,
       attempt: attemptWord,
       similarity: similarity(referenceWord, attemptWord),
@@ -1247,6 +1247,101 @@ var DeferredScoringError = class extends Error {
   activityType;
 };
 
+// src/count-words.ts
+function countWords(text) {
+  if (typeof text !== "string") {
+    return 0;
+  }
+  const trimmed = text.trim();
+  if (trimmed === "") {
+    return 0;
+  }
+  return trimmed.split(/\s+/).length;
+}
+
+// src/scoring/text-match.ts
+var COMBINING_MARKS_RE = /\p{M}/gu;
+var PUNCTUATION_RE2 = /\p{P}/gu;
+function applyBaseline(value, policy) {
+  let result = value;
+  if (policy.trim !== false) {
+    result = result.trim();
+  }
+  if (policy.caseSensitive !== true) {
+    result = policy.locale ? result.toLocaleLowerCase(policy.locale) : result.toLowerCase();
+  }
+  return result;
+}
+function applyNormalization(value, policy) {
+  let result = value;
+  if (policy.normalize === "NFC" || policy.normalize === "NFKC") {
+    result = result.normalize(policy.normalize);
+  }
+  if (policy.ignorePunctuation === true) {
+    result = result.replace(PUNCTUATION_RE2, "");
+  }
+  if (policy.collapseInnerWhitespace === true) {
+    result = result.replace(/(?<=\S)\s+(?=\S)/g, " ");
+    if (policy.trim !== false) {
+      result = result.trim();
+    }
+  }
+  return result;
+}
+function applyDiacriticFold(value) {
+  return value.normalize("NFD").replace(COMBINING_MARKS_RE, "").normalize("NFC");
+}
+function levenshteinDistance(a, b, max) {
+  if (a === b) return 0;
+  if (Math.abs(a.length - b.length) > max) return max + 1;
+  if (a.length === 0) return b.length;
+  if (b.length === 0) return a.length;
+  let previous = Array.from({ length: b.length + 1 }, (_, i) => i);
+  for (let i = 1; i <= a.length; i += 1) {
+    const current = [i];
+    let rowMin = i;
+    for (let j = 1; j <= b.length; j += 1) {
+      const cost = a[i - 1] === b[j - 1] ? 0 : 1;
+      const value = Math.min(
+        previous[j] + 1,
+        current[j - 1] + 1,
+        previous[j - 1] + cost
+      );
+      current.push(value);
+      if (value < rowMin) rowMin = value;
+    }
+    if (rowMin > max) return max + 1;
+    previous = current;
+  }
+  return previous[b.length];
+}
+function matchText(input, accepted, policy = {}) {
+  const acceptedList = typeof accepted === "string" ? [accepted] : accepted;
+  const baselineInput = applyBaseline(input, policy);
+  const baselineAccepted = acceptedList.map((answer) => applyBaseline(answer, policy));
+  if (baselineAccepted.some((answer) => answer === baselineInput)) {
+    return { matched: true, via: "exact" };
+  }
+  const usesNormalization = policy.normalize === "NFC" || policy.normalize === "NFKC" || policy.ignorePunctuation === true || policy.collapseInnerWhitespace === true;
+  const normalizedInput = usesNormalization ? applyNormalization(baselineInput, policy) : baselineInput;
+  const normalizedAccepted = usesNormalization ? baselineAccepted.map((answer) => applyNormalization(answer, policy)) : baselineAccepted;
+  if (usesNormalization && normalizedAccepted.some((answer) => answer === normalizedInput)) {
+    return { matched: true, via: "normalized" };
+  }
+  const foldedInput = policy.foldDiacritics === true ? applyDiacriticFold(normalizedInput) : normalizedInput;
+  const foldedAccepted = policy.foldDiacritics === true ? normalizedAccepted.map((answer) => applyDiacriticFold(answer)) : normalizedAccepted;
+  if (policy.foldDiacritics === true && foldedAccepted.some((answer) => answer === foldedInput)) {
+    return { matched: true, via: "folded" };
+  }
+  const maxDistance = policy.levenshtein ?? 0;
+  if (maxDistance > 0 && foldedInput.trim().length > 0 && foldedAccepted.some(
+    (answer) => levenshteinDistance(foldedInput, answer, maxDistance) <= maxDistance
+  )) {
+    return { matched: true, via: "fuzzy" };
+  }
+  return { matched: false, via: "none" };
+}
+
 // src/schemas/multiple-choice.ts
 import { z as z4 } from "zod/v4";
 
@@ -1327,18 +1422,6 @@ var READ_ALOUD_MAX_DIMENSION_WEIGHT = 1e3;
 var SPEECH_ASSESSMENT_MAX_WORDS = 1e3;
 var SPEECH_ASSESSMENT_MAX_TEXT_LENGTH = DICTATION_MAX_TEXT_LENGTH;
 
-// src/count-words.ts
-function countWords(text) {
-  if (typeof text !== "string") {
-    return 0;
-  }
-  const trimmed = text.trim();
-  if (trimmed === "") {
-    return 0;
-  }
-  return trimmed.split(/\s+/).length;
-}
-
 // src/schemas/read-schema.ts
 var OWN_SCHEMAS = /* @__PURE__ */ new WeakSet();
 function ownSchemas(...schemas) {
@@ -1424,89 +1507,6 @@ function standardJsonSchemaOf(schema) {
   return generated !== null && typeof generated === "object" && !Array.isArray(generated) ? generated : void 0;
 }
 
-// src/scoring/text-match.ts
-var COMBINING_MARKS_RE = /\p{M}/gu;
-var PUNCTUATION_RE2 = /\p{P}/gu;
-function applyBaseline(value, policy) {
-  let result = value;
-  if (policy.trim !== false) {
-    result = result.trim();
-  }
-  if (policy.caseSensitive !== true) {
-    result = policy.locale ? result.toLocaleLowerCase(policy.locale) : result.toLowerCase();
-  }
-  return result;
-}
-function applyNormalization(value, policy) {
-  let result = value;
-  if (policy.normalize === "NFC" || policy.normalize === "NFKC") {
-    result = result.normalize(policy.normalize);
-  }
-  if (policy.ignorePunctuation === true) {
-    result = result.replace(PUNCTUATION_RE2, "");
-  }
-  if (policy.collapseInnerWhitespace === true) {
-    result = result.replace(/(?<=\S)\s+(?=\S)/g, " ");
-    if (policy.trim !== false) {
-      result = result.trim();
-    }
-  }
-  return result;
-}
-function applyDiacriticFold(value) {
-  return value.normalize("NFD").replace(COMBINING_MARKS_RE, "").normalize("NFC");
-}
-function levenshteinDistance(a, b, max) {
-  if (a === b) return 0;
-  if (Math.abs(a.length - b.length) > max) return max + 1;
-  if (a.length === 0) return b.length;
-  if (b.length === 0) return a.length;
-  let previous = Array.from({ length: b.length + 1 }, (_, i) => i);
-  for (let i = 1; i <= a.length; i += 1) {
-    const current = [i];
-    let rowMin = i;
-    for (let j = 1; j <= b.length; j += 1) {
-      const cost = a[i - 1] === b[j - 1] ? 0 : 1;
-      const value = Math.min(
-        previous[j] + 1,
-        current[j - 1] + 1,
-        previous[j - 1] + cost
-      );
-      current.push(value);
-      if (value < rowMin) rowMin = value;
-    }
-    if (rowMin > max) return max + 1;
-    previous = current;
-  }
-  return previous[b.length];
-}
-function matchText(input, accepted, policy = {}) {
-  const acceptedList = typeof accepted === "string" ? [accepted] : accepted;
-  const baselineInput = applyBaseline(input, policy);
-  const baselineAccepted = acceptedList.map((answer) => applyBaseline(answer, policy));
-  if (baselineAccepted.some((answer) => answer === baselineInput)) {
-    return { matched: true, via: "exact" };
-  }
-  const usesNormalization = policy.normalize === "NFC" || policy.normalize === "NFKC" || policy.ignorePunctuation === true || policy.collapseInnerWhitespace === true;
-  const normalizedInput = usesNormalization ? applyNormalization(baselineInput, policy) : baselineInput;
-  const normalizedAccepted = usesNormalization ? baselineAccepted.map((answer) => applyNormalization(answer, policy)) : baselineAccepted;
-  if (usesNormalization && normalizedAccepted.some((answer) => answer === normalizedInput)) {
-    return { matched: true, via: "normalized" };
-  }
-  const foldedInput = policy.foldDiacritics === true ? applyDiacriticFold(normalizedInput) : normalizedInput;
-  const foldedAccepted = policy.foldDiacritics === true ? normalizedAccepted.map((answer) => applyDiacriticFold(answer)) : normalizedAccepted;
-  if (policy.foldDiacritics === true && foldedAccepted.some((answer) => answer === foldedInput)) {
-    return { matched: true, via: "folded" };
-  }
-  const maxDistance = policy.levenshtein ?? 0;
-  if (maxDistance > 0 && foldedInput.trim().length > 0 && foldedAccepted.some(
-    (answer) => levenshteinDistance(foldedInput, answer, maxDistance) <= maxDistance
-  )) {
-    return { matched: true, via: "fuzzy" };
-  }
-  return { matched: false, via: "none" };
-}
-
 // src/registry/registry.ts
 var registry = /* @__PURE__ */ new Map();
 function defineActivityType(descriptor) {
@@ -1768,12 +1768,12 @@ var DictationDataSchema = DictationDataShape.check(
   })
 );
 var isObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
-function captionFieldsOf(media, written = (captionsUrl) => captionsUrl !== void 0) {
+function captionFieldsOf(media, written2 = (captionsUrl) => captionsUrl !== void 0) {
   if (!isObject(media)) {
     return [];
   }
   const fields = [];
-  if (written(media.captionsUrl)) {
+  if (written2(media.captionsUrl)) {
     fields.push("captionsUrl");
   }
   if (Array.isArray(media.tracks) && media.tracks.length > 0) {
@@ -1781,11 +1781,11 @@ function captionFieldsOf(media, written = (captionsUrl) => captionsUrl !== void
   }
   return fields;
 }
-function groupCaptionsField(group, written) {
+function groupCaptionsField(group, written2) {
   if (!isObject(group) || !isObject(group.stimulus) || !Array.isArray(group.items)) {
     return void 0;
   }
-  const [field] = captionFieldsOf(group.stimulus.media, written);
+  const [field] = captionFieldsOf(group.stimulus.media, written2);
   if (field === void 0) {
     return void 0;
   }
@@ -2562,6 +2562,499 @@ var FillInTheBlanksDataSchema = z7.looseObject({
   }
 );
 
+// src/answer-leak.ts
+function placeholderOrder(passage) {
+  return [...passage.matchAll(PLACEHOLDER_RE)].map((match) => match[1]);
+}
+function numberedPassage(passage) {
+  let position = 0;
+  return passage.replace(PLACEHOLDER_RE, () => {
+    position += 1;
+    return `[${position}]`;
+  });
+}
+function passageWithoutPlaceholders(passage) {
+  return passage.replace(PLACEHOLDER_RE, " ");
+}
+function fold(text) {
+  const folded2 = text.normalize("NFKD").replace(/\p{M}/gu, "").toLowerCase().replace(/[^\p{L}\p{N}]+/gu, " ").trim();
+  return folded2 === "" ? [] : folded2.split(" ");
+}
+function containsWords(haystack, needle) {
+  if (needle.length === 0 || needle.length > haystack.length) {
+    return false;
+  }
+  for (let start = 0; start + needle.length <= haystack.length; start += 1) {
+    let match = true;
+    for (let offset = 0; offset < needle.length; offset += 1) {
+      if (haystack[start + offset] !== needle[offset]) {
+        match = false;
+        break;
+      }
+    }
+    if (match) {
+      return true;
+    }
+  }
+  return false;
+}
+var isShort = (words) => words.length === 1 && [...words[0]].length < 4;
+function neighbours(passage, position) {
+  const marker = `[${position}]`;
+  const at = passage.indexOf(marker);
+  if (at === -1) {
+    return {};
+  }
+  const strip = (text) => text.replace(/\[\d+\]/g, " ");
+  const left = fold(strip(passage.slice(0, at)));
+  const right = fold(strip(passage.slice(at + marker.length)));
+  const before = left[left.length - 1];
+  const after = right[0];
+  return {
+    ...before !== void 0 ? { before } : {},
+    ...after !== void 0 ? { after } : {}
+  };
+}
+function revealsAnswer(text, answer, passage, position) {
+  const words = fold(text);
+  const needle = fold(answer);
+  if (needle.length === 0) {
+    return false;
+  }
+  if (!isShort(needle) || passage === void 0 || position === void 0) {
+    return containsWords(words, needle);
+  }
+  const { before, after } = neighbours(passage, position);
+  if (before === void 0 && after === void 0) {
+    return containsWords(words, needle);
+  }
+  return before !== void 0 && containsWords(words, [before, ...needle]) || after !== void 0 && containsWords(words, [...needle, after]);
+}
+
+// src/scoring/strategies/all-or-nothing.ts
+function allOrNothingStrategy(correctItems) {
+  return correctItems.every((isCorrect) => isCorrect) ? 1 : 0;
+}
+
+// src/scoring/strategies/partial.ts
+function partialStrategy(correctSelected, incorrectSelected, totalCorrect, totalIncorrect) {
+  const reward = correctSelected / totalCorrect;
+  const penalty = totalIncorrect === 0 ? 0 : incorrectSelected / totalIncorrect;
+  return Math.max(0, reward - penalty);
+}
+function partialBlankStrategy(correctBlanks, totalBlanks) {
+  return correctBlanks / totalBlanks;
+}
+
+// src/scoring/activity-scorers/fill-in-the-blanks.ts
+function policyFor(blank) {
+  return {
+    ...blank.caseSensitive !== void 0 ? { caseSensitive: blank.caseSensitive } : {},
+    ...blank.trimWhitespace !== void 0 ? { trim: blank.trimWhitespace } : {},
+    ...blank.match
+  };
+}
+function scoreFillInTheBlanks(data, response) {
+  const details = [];
+  const perBlankCorrect = [];
+  for (const blank of data.blanks) {
+    const rawInput = response.answers[blank.id];
+    const input = typeof rawInput === "string" ? rawInput : "";
+    const matched = matchText(input, blank.acceptedAnswers, policyFor(blank)).matched;
+    perBlankCorrect.push(matched);
+    details.push({
+      itemId: blank.id,
+      outcome: matched ? "correct" : "incorrect",
+      learnerResponse: [input],
+      correctResponse: [...blank.acceptedAnswers],
+      weight: 1
+    });
+  }
+  const correctBlanks = perBlankCorrect.filter(Boolean).length;
+  const scoreValue = data.scoringStrategy === "all-or-nothing" ? allOrNothingStrategy(perBlankCorrect) : partialBlankStrategy(correctBlanks, data.blanks.length);
+  return { score: scoreValue, maxScore: 1, feedback: null, details };
+}
+
+// src/authoring/findings.ts
+var ITEM_FINDING_SEVERITY = {
+  // multiple-choice
+  mc_title_reveals_answer: "warning",
+  mc_options_duplicate: "warning",
+  mc_key_longest: "warning",
+  mc_every_option_correct: "warning",
+  mc_above_option_shuffled: "warning",
+  mc_above_option: "advice",
+  // fill-in-the-blanks
+  fib_title_reveals_answer: "warning",
+  fib_hint_reveals_answer: "warning",
+  fib_answer_in_passage: "warning",
+  fib_accepted_answer_redundant: "advice",
+  // gap-select
+  gs_title_reveals_answer: "warning",
+  gs_choices_duplicate: "warning",
+  gs_bank_no_distractor: "warning",
+  gs_answer_in_passage: "warning",
+  // written-response
+  wr_criterion_name_duplicate: "warning",
+  // read-aloud
+  ra_text_long_for_time: "warning",
+  // a set of items: a quiz, or an item group's items
+  set_key_position_same: "warning"
+};
+function finding(code, path, message) {
+  return { path: path.map(String), message, code, severity: ITEM_FINDING_SEVERITY[code] };
+}
+function normaliseFinding(found) {
+  const documented = Object.hasOwn(ITEM_FINDING_SEVERITY, found.code) ? ITEM_FINDING_SEVERITY[found.code] : void 0;
+  return {
+    ...found,
+    path: found.path.map(String),
+    severity: documented ?? (found.severity === "advice" ? "advice" : "warning")
+  };
+}
+
+// src/authoring/critique.ts
+var written = (value) => typeof value === "string" && !isUnwritten(value) ? value : void 0;
+var folded = (text) => fold(text).join(" ");
+var listOf = (value) => Array.isArray(value) ? value : [];
+var lengthOf = (text) => [...text.trim()].length;
+var ordinal = (index) => index + 1;
+function duplicates(entries, textOf) {
+  const seen = /* @__PURE__ */ new Map();
+  const pairs = [];
+  entries.forEach((entry, index) => {
+    const text = textOf(entry);
+    if (text === void 0) {
+      return;
+    }
+    const key = folded(text);
+    if (key === "") {
+      return;
+    }
+    const first = seen.get(key);
+    if (first === void 0) {
+      seen.set(key, index);
+    } else {
+      pairs.push({ first, second: index });
+    }
+  });
+  return pairs;
+}
+function printedIn(passage, answer) {
+  const needle = fold(answer);
+  return needle.length > 0 && !isShort(needle) && containsWords(fold(passageWithoutPlaceholders(passage)), needle);
+}
+var POSITIONAL = /(^| )(the above|las anteriores|los anteriores|as anteriores|os anteriores|[a-h] (and|or|y|o|e|ou) [a-h])( |$)/;
+var AGGREGATE = /(^| )(all of the above|none of the above|todas las anteriores|ninguna de las anteriores|todas as anteriores|nenhuma das anteriores)( |$)/;
+var KEY_LONGEST_RATIO = 1.5;
+var KEY_LONGEST_MARGIN = 10;
+function critiqueMultipleChoice(draft) {
+  const findings = [];
+  const options = listOf(draft.options);
+  const texts = options.map((option) => isRecord(option) ? written(option.text) : void 0);
+  const correct = options.map((option) => isRecord(option) && option.isCorrect === true);
+  const hasMedia = options.map((option) => isRecord(option) && option.media !== void 0);
+  const title = written(draft.title);
+  const revealed = options.findIndex(
+    (_, index) => correct[index] === true && title !== void 0 && texts[index] !== void 0 && revealsAnswer(title, texts[index])
+  );
+  if (revealed !== -1) {
+    findings.push(
+      finding(
+        "mc_title_reveals_answer",
+        ["title"],
+        `The title, which the learner sees, contains the right answer ("${texts[revealed]}").`
+      )
+    );
+  }
+  for (const { first, second } of duplicates(
+    options,
+    (option) => isRecord(option) && option.media === void 0 ? written(option.text) : void 0
+  )) {
+    findings.push(
+      finding(
+        "mc_options_duplicate",
+        ["options", second, "text"],
+        `Options ${ordinal(first)} and ${ordinal(second)} read the same, so a learner cannot tell them apart.`
+      )
+    );
+  }
+  const keys = correct.flatMap((isKey, index) => isKey ? [index] : []);
+  if (draft.mode === "single" && options.length >= 3 && keys.length === 1 && texts.every((text) => text !== void 0) && !hasMedia.some(Boolean)) {
+    const key = keys[0];
+    const keyLength = lengthOf(texts[key]);
+    const longestOther = Math.max(
+      ...texts.flatMap((text, index) => index === key ? [] : [lengthOf(text)])
+    );
+    if (keyLength >= longestOther * KEY_LONGEST_RATIO && keyLength - longestOther >= KEY_LONGEST_MARGIN) {
+      findings.push(
+        finding(
+          "mc_key_longest",
+          ["options", key, "text"],
+          "The right option is much longer than every other, and a test-wise learner picks the longest. Bring the options to a similar length."
+        )
+      );
+    }
+  }
+  if (draft.mode === "multi" && options.length >= 2 && correct.every(Boolean)) {
+    findings.push(
+      finding(
+        "mc_every_option_correct",
+        ["options"],
+        "Every option is correct, so a learner who selects them all scores full marks without reading them."
+      )
+    );
+  }
+  texts.forEach((text, index) => {
+    if (text === void 0) {
+      return;
+    }
+    const words = folded(text);
+    if (draft.shuffle === true && POSITIONAL.test(words)) {
+      findings.push(
+        finding(
+          "mc_above_option_shuffled",
+          ["options", index, "text"],
+          `Option ${ordinal(index)} points at other options by position, and this question shuffles them: after shuffling it points at the wrong ones.`
+        )
+      );
+    } else if (AGGREGATE.test(words)) {
+      findings.push(
+        finding(
+          "mc_above_option",
+          ["options", index, "text"],
+          `Option ${ordinal(index)} is "all" or "none of the above". A learner who spots two right options can choose "all" without knowing the rest; "none" tests only what is wrong.`
+        )
+      );
+    }
+  });
+  return findings;
+}
+function redundantUnder(blank, earlier, later) {
+  try {
+    const { levenshtein: _typos, ...policy } = policyFor(blank);
+    return matchText(later, earlier, policy).matched;
+  } catch {
+    return false;
+  }
+}
+function critiqueFillInTheBlanks(draft) {
+  const findings = [];
+  const passage = typeof draft.passage === "string" ? draft.passage : "";
+  const numbered = numberedPassage(passage);
+  const order = placeholderOrder(passage);
+  const blanks = listOf(draft.blanks);
+  const answersOf = (blank) => isRecord(blank) ? listOf(blank.acceptedAnswers).flatMap((answer) => written(answer) ?? []) : [];
+  const positionOf = (blank) => {
+    const at = isRecord(blank) && typeof blank.id === "string" ? order.indexOf(blank.id) : -1;
+    return at === -1 ? void 0 : at + 1;
+  };
+  const title = written(draft.title);
+  if (title !== void 0 && blanks.some(
+    (blank) => answersOf(blank).some((answer) => revealsAnswer(title, answer, numbered, positionOf(blank)))
+  )) {
+    findings.push(
+      finding(
+        "fib_title_reveals_answer",
+        ["title"],
+        "The title, which the learner sees, contains an answer to a blank."
+      )
+    );
+  }
+  blanks.forEach((blank, index) => {
+    if (!isRecord(blank)) {
+      return;
+    }
+    const answers = answersOf(blank);
+    const hint = written(blank.hint);
+    if (hint !== void 0 && answers.some((answer) => revealsAnswer(hint, answer, numbered, positionOf(blank)))) {
+      findings.push(
+        finding(
+          "fib_hint_reveals_answer",
+          ["blanks", index, "hint"],
+          `The hint for blank ${ordinal(index)} contains its answer.`
+        )
+      );
+    }
+    const accepted = listOf(blank.acceptedAnswers);
+    const printed = accepted.findIndex((answer) => {
+      const text = written(answer);
+      return text !== void 0 && printedIn(passage, text);
+    });
+    if (printed !== -1) {
+      findings.push(
+        finding(
+          "fib_answer_in_passage",
+          ["blanks", index, "acceptedAnswers", printed],
+          `The passage prints "${accepted[printed]}", an answer to blank ${ordinal(index)}, where the learner can copy it.`
+        )
+      );
+    }
+    accepted.forEach((later, laterIndex) => {
+      const laterText = written(later);
+      if (laterText === void 0) {
+        return;
+      }
+      const earlier = accepted.slice(0, laterIndex).findIndex((candidate) => {
+        const text = written(candidate);
+        return text !== void 0 && redundantUnder(blank, text, laterText);
+      });
+      if (earlier !== -1) {
+        findings.push(
+          finding(
+            "fib_accepted_answer_redundant",
+            ["blanks", index, "acceptedAnswers", laterIndex],
+            `"${laterText}" is already accepted as "${accepted[earlier]}" under this blank's matching.`
+          )
+        );
+      }
+    });
+  });
+  return findings;
+}
+function critiqueGapSelect(draft) {
+  const findings = [];
+  const passage = typeof draft.passage === "string" ? draft.passage : "";
+  const numbered = numberedPassage(passage);
+  const order = placeholderOrder(passage);
+  const gaps = listOf(draft.gaps);
+  const banks = listOf(draft.banks);
+  const choiceText = (choice) => isRecord(choice) ? written(choice.text) : void 0;
+  const choicesOf = (gap) => {
+    if (Array.isArray(gap.choices)) {
+      return gap.choices;
+    }
+    const bank = banks.find((candidate) => isRecord(candidate) && candidate.id === gap.bankId);
+    return isRecord(bank) ? listOf(bank.choices) : [];
+  };
+  const answerOf = (gap) => choiceText(
+    choicesOf(gap).find((choice) => isRecord(choice) && choice.id === gap.correctChoiceId)
+  );
+  const positionOf = (gap) => {
+    const at = typeof gap.id === "string" ? order.indexOf(gap.id) : -1;
+    return at === -1 ? void 0 : at + 1;
+  };
+  const title = written(draft.title);
+  if (title !== void 0 && gaps.some((gap) => {
+    if (!isRecord(gap)) {
+      return false;
+    }
+    const answer = answerOf(gap);
+    return answer !== void 0 && revealsAnswer(title, answer, numbered, positionOf(gap));
+  })) {
+    findings.push(
+      finding(
+        "gs_title_reveals_answer",
+        ["title"],
+        "The title, which the learner sees, contains the answer to a gap."
+      )
+    );
+  }
+  const reportDuplicates = (choices, path) => {
+    for (const { first, second } of duplicates(choices, choiceText)) {
+      findings.push(
+        finding(
+          "gs_choices_duplicate",
+          [...path, "choices", second, "text"],
+          `Choices ${ordinal(first)} and ${ordinal(second)} read the same, so a learner cannot tell them apart.`
+        )
+      );
+    }
+  };
+  gaps.forEach((gap, index) => {
+    if (!isRecord(gap)) {
+      return;
+    }
+    if (Array.isArray(gap.choices)) {
+      reportDuplicates(gap.choices, ["gaps", index]);
+    }
+    const answer = answerOf(gap);
+    if (answer !== void 0 && printedIn(passage, answer)) {
+      findings.push(
+        finding(
+          "gs_answer_in_passage",
+          ["gaps", index, "correctChoiceId"],
+          `The passage prints "${answer}", the answer to gap ${ordinal(index)}.`
+        )
+      );
+    }
+  });
+  banks.forEach((bank, index) => {
+    if (!isRecord(bank)) {
+      return;
+    }
+    const choices = listOf(bank.choices);
+    reportDuplicates(choices, ["banks", index]);
+    const drawnOn = gaps.filter((gap) => isRecord(gap) && gap.bankId === bank.id).length;
+    if (drawnOn >= 2 && choices.length <= drawnOn) {
+      findings.push(
+        finding(
+          "gs_bank_no_distractor",
+          ["banks", index, "choices"],
+          `This bank offers ${choices.length} choices to ${drawnOn} gaps, so the last gap is answered by elimination. Add a choice that answers no gap.`
+        )
+      );
+    }
+  });
+  return findings;
+}
+function critiqueWrittenResponse(draft) {
+  const rubric = isRecord(draft.rubric) ? draft.rubric : void 0;
+  const criteria = rubric === void 0 ? [] : listOf(rubric.criteria);
+  return duplicates(
+    criteria,
+    (criterion) => isRecord(criterion) ? written(criterion.name) : void 0
+  ).map(
+    ({ first, second }) => finding(
+      "wr_criterion_name_duplicate",
+      ["rubric", "criteria", second, "name"],
+      `Criteria ${ordinal(first)} and ${ordinal(second)} have the same name. Feedback and grades name a criterion, so one of them cannot be told apart.`
+    )
+  );
+}
+var WORDS_PER_SECOND = 2.5;
+function critiqueReadAloud(draft) {
+  const text = written(draft.referenceText);
+  const recording = isRecord(draft.recording) ? draft.recording : void 0;
+  const maxSeconds = recording?.maxSeconds;
+  if (text === void 0 || typeof maxSeconds !== "number" || !(maxSeconds > 0)) {
+    return [];
+  }
+  const words = countWords(text);
+  if (words / maxSeconds <= WORDS_PER_SECOND) {
+    return [];
+  }
+  return [
+    finding(
+      "ra_text_long_for_time",
+      ["recording", "maxSeconds"],
+      `${words} words in ${maxSeconds} seconds is faster than a fluent reader reads aloud (${WORDS_PER_SECOND} words a second). Allow at least ${Math.ceil(words / WORDS_PER_SECOND)} seconds, or shorten the text.`
+    )
+  ];
+}
+var KEY_POSITION_MINIMUM = 4;
+function keyPositionFinding(items, path) {
+  const positions = items.flatMap((item) => {
+    if (!isRecord(item) || item.type !== "multiple-choice" || item.mode !== "single" || item.shuffle === true) {
+      return [];
+    }
+    const keys = listOf(item.options).flatMap(
+      (option, index) => isRecord(option) && option.isCorrect === true ? [index] : []
+    );
+    return keys.length === 1 ? keys : [];
+  });
+  if (positions.length < KEY_POSITION_MINIMUM || !positions.every((at) => at === positions[0])) {
+    return [];
+  }
+  return [
+    finding(
+      "set_key_position_same",
+      path,
+      `In all ${positions.length} single-answer questions the right option is option ${ordinal(positions[0])}. Vary its position, or shuffle the options.`
+    )
+  ];
+}
+
 // src/authoring/fill-in-the-blanks.ts
 var fillInTheBlanksAuthoring = {
   createDraft: ({ newId }) => ({
@@ -2573,7 +3066,8 @@ var fillInTheBlanksAuthoring = {
     blanks: [],
     scoringStrategy: "all-or-nothing"
   }),
-  checkDraft: checkFillInTheBlanksDraft
+  checkDraft: checkFillInTheBlanksDraft,
+  critique: critiqueFillInTheBlanks
 };
 function checkFillInTheBlanksDraft(draft) {
   const issues = checkIdentity(draft, "fill-in-the-blanks");
@@ -2767,7 +3261,8 @@ var gapSelectAuthoring = {
     gaps: [],
     scoringStrategy: "all-or-nothing"
   }),
-  checkDraft: checkGapSelectDraft
+  checkDraft: checkGapSelectDraft,
+  critique: critiqueGapSelect
 };
 function checkGapSelectDraft(draft) {
   const issues = checkIdentity(draft, "gap-select");
@@ -2846,10 +3341,10 @@ function checkGaps(gaps, banks, bankIds, gapIds) {
     if (!isRecord(gap)) {
       continue;
     }
-    const ordinal = index + 1;
-    const name = typeof gap.id === "string" && gap.id !== "" ? `"${gap.id}"` : ordinal;
+    const ordinal2 = index + 1;
+    const name = typeof gap.id === "string" && gap.id !== "" ? `"${gap.id}"` : ordinal2;
     if (isMissingId(gap.id)) {
-      issues.push(issue("gs_gap_id_required", ["gaps", index, "id"], `Gap ${ordinal} has no id.`));
+      issues.push(issue("gs_gap_id_required", ["gaps", index, "id"], `Gap ${ordinal2} has no id.`));
     } else if (typeof gap.id === "string") {
       if (seen.has(gap.id)) {
         repeated.add(gap.id);
@@ -3067,7 +3562,8 @@ var multipleChoiceAuthoring = {
       { id: newId(), text: "", isCorrect: false }
     ]
   }),
-  checkDraft: checkMultipleChoiceDraft
+  checkDraft: checkMultipleChoiceDraft,
+  critique: critiqueMultipleChoice
 };
 function checkMultipleChoiceDraft(draft) {
   const issues = checkIdentity(draft, "multiple-choice");
@@ -3097,10 +3593,10 @@ function checkMultipleChoiceDraft(draft) {
       if (!isRecord(option)) {
         continue;
       }
-      const ordinal = index + 1;
+      const ordinal2 = index + 1;
       if (isMissingId(option.id)) {
         issues.push(
-          issue("mc_option_id_required", ["options", index, "id"], `Option ${ordinal} has no id.`)
+          issue("mc_option_id_required", ["options", index, "id"], `Option ${ordinal2} has no id.`)
         );
       } else if (typeof option.id === "string") {
         if (seen.has(option.id)) {
@@ -3113,7 +3609,7 @@ function checkMultipleChoiceDraft(draft) {
           issue(
             "mc_option_text_required",
             ["options", index, "text"],
-            `Write the text of option ${ordinal}.`
+            `Write the text of option ${ordinal2}.`
           )
         );
       }
@@ -3122,7 +3618,7 @@ function checkMultipleChoiceDraft(draft) {
           issue(
             "mc_option_correctness_required",
             ["options", index, "isCorrect"],
-            `Say whether option ${ordinal} is correct.`
+            `Say whether option ${ordinal2} is correct.`
           )
         );
       }
@@ -3130,7 +3626,7 @@ function checkMultipleChoiceDraft(draft) {
         correct += 1;
       }
       if (isRecord(option.media)) {
-        issues.push(...checkOptionMedia(option.media, index, ordinal));
+        issues.push(...checkOptionMedia(option.media, index, ordinal2));
       }
     }
     for (const id of repeated) {
@@ -3159,7 +3655,7 @@ function checkMultipleChoiceDraft(draft) {
   issues.push(...checkSharedOptional(draft));
   return issues;
 }
-function checkOptionMedia(media, index, ordinal) {
+function checkOptionMedia(media, index, ordinal2) {
   const path = ["options", index, "media"];
   const kind = media.type;
   if (kind === "video" || kind === "embed") {
@@ -3167,7 +3663,7 @@ function checkOptionMedia(media, index, ordinal) {
       issue(
         "mc_option_media_kind",
         [...path, "type"],
-        `Option ${ordinal} carries ${kind === "embed" ? "an embedded player" : "a video"}, which cannot be an option: its controls swallow the click that selects the answer. Use a picture or a recording.`
+        `Option ${ordinal2} carries ${kind === "embed" ? "an embedded player" : "a video"}, which cannot be an option: its controls swallow the click that selects the answer. Use a picture or a recording.`
       )
     ];
   }
@@ -3335,7 +3831,8 @@ var readAloudAuthoring = {
     recording: { maxSeconds: 0 },
     scoring: { dimensions: [] }
   }),
-  checkDraft: checkReadAloudDraft
+  checkDraft: checkReadAloudDraft,
+  critique: critiqueReadAloud
 };
 function checkReadAloudDraft(draft) {
   const issues = checkIdentity(draft, "read-aloud");
@@ -3611,7 +4108,8 @@ var writtenResponseAuthoring = {
     minWords: 0,
     maxWords: 0
   }),
-  checkDraft: checkWrittenResponseDraft
+  checkDraft: checkWrittenResponseDraft,
+  critique: critiqueWrittenResponse
 };
 function checkWrittenResponseDraft(draft) {
   const issues = checkIdentity(draft, "written-response");
@@ -3691,11 +4189,11 @@ function checkCriteria(criteria) {
       everyWeightUsable = false;
       continue;
     }
-    const ordinal = index + 1;
+    const ordinal2 = index + 1;
     const path = ["rubric", "criteria", index];
     if (isUnwritten(criterion.name)) {
       issues.push(
-        issue("wr_criterion_name_required", [...path, "name"], `Name rubric criterion ${ordinal}.`)
+        issue("wr_criterion_name_required", [...path, "name"], `Name rubric criterion ${ordinal2}.`)
       );
     }
     const weight = criterion.weight;
@@ -3705,7 +4203,7 @@ function checkCriteria(criteria) {
         issue(
           "wr_criterion_weight_required",
           [...path, "weight"],
-          `Give rubric criterion ${ordinal} a weight.`
+          `Give rubric criterion ${ordinal2} a weight.`
         )
       );
     } else if (!(typeof weight === "number" && Number.isFinite(weight) && weight >= 0)) {
@@ -4085,50 +4583,6 @@ function scoreDictation(data, response) {
   return { score: alignment.similarity, maxScore: 1, feedback: null, details };
 }
 
-// src/scoring/strategies/all-or-nothing.ts
-function allOrNothingStrategy(correctItems) {
-  return correctItems.every((isCorrect) => isCorrect) ? 1 : 0;
-}
-
-// src/scoring/strategies/partial.ts
-function partialStrategy(correctSelected, incorrectSelected, totalCorrect, totalIncorrect) {
-  const reward = correctSelected / totalCorrect;
-  const penalty = totalIncorrect === 0 ? 0 : incorrectSelected / totalIncorrect;
-  return Math.max(0, reward - penalty);
-}
-function partialBlankStrategy(correctBlanks, totalBlanks) {
-  return correctBlanks / totalBlanks;
-}
-
-// src/scoring/activity-scorers/fill-in-the-blanks.ts
-function policyFor(blank) {
-  return {
-    ...blank.caseSensitive !== void 0 ? { caseSensitive: blank.caseSensitive } : {},
-    ...blank.trimWhitespace !== void 0 ? { trim: blank.trimWhitespace } : {},
-    ...blank.match
-  };
-}
-function scoreFillInTheBlanks(data, response) {
-  const details = [];
-  const perBlankCorrect = [];
-  for (const blank of data.blanks) {
-    const rawInput = response.answers[blank.id];
-    const input = typeof rawInput === "string" ? rawInput : "";
-    const matched = matchText(input, blank.acceptedAnswers, policyFor(blank)).matched;
-    perBlankCorrect.push(matched);
-    details.push({
-      itemId: blank.id,
-      outcome: matched ? "correct" : "incorrect",
-      learnerResponse: [input],
-      correctResponse: [...blank.acceptedAnswers],
-      weight: 1
-    });
-  }
-  const correctBlanks = perBlankCorrect.filter(Boolean).length;
-  const scoreValue = data.scoringStrategy === "all-or-nothing" ? allOrNothingStrategy(perBlankCorrect) : partialBlankStrategy(correctBlanks, data.blanks.length);
-  return { score: scoreValue, maxScore: 1, feedback: null, details };
-}
-
 // src/scoring/activity-scorers/gap-select.ts
 function choicesFor(data, gap) {
   if (gap.choices !== void 0) {
@@ -4532,8 +4986,12 @@ export {
   maxUnits,
   MediaSchema,
   RedactedMediaSchema,
-  PLACEHOLDER_RE,
   FillInTheBlanksDataSchema,
+  placeholderOrder,
+  numberedPassage,
+  fold,
+  containsWords,
+  revealsAnswer,
   withValidationScope,
   DICTATION_MAX_TRANSCRIPT_LENGTH,
   DICTATION_MAX_TEXT_LENGTH,
@@ -4564,6 +5022,11 @@ export {
   covers,
   pathKey,
   coveredPathsOf,
+  countWords,
+  levenshteinDistance,
+  matchText,
+  normaliseFinding,
+  keyPositionFinding,
   MultipleChoiceOptionMediaSchema,
   MultipleChoiceDataSchema,
   READ_ALOUD_MAX_REFERENCE_LENGTH,
@@ -4574,14 +5037,11 @@ export {
   SPEECH_ASSESSMENT_MAX_TEXT_LENGTH,
   CANONICAL_LOCALE_RE,
   ReadAloudDataSchema,
-  countWords,
   GapSelectDataSchema,
   isOwnSchema,
   readSchema,
   standardJsonSchemaOf,
   WrittenResponseDataSchema,
-  levenshteinDistance,
-  matchText,
   defineActivityType,
   registerActivityType,
   getActivityTypeDescriptor,
@@ -4594,4 +5054,4 @@ export {
   dictationType,
   readAloudType
 };
-//# sourceMappingURL=chunk-FBKTION6.js.map
+//# sourceMappingURL=chunk-QS7B42ZR.js.map