@intellectif/lk-core 0.12.0 → 0.13.0

package/dist/{chunk-FVN37GIH.js → chunk-XKKKWKRH.js}

@@ -38,6 +38,876 @@ var DeferredScoringError = class extends Error {
   activityType;
 };
 
+// src/validation-scope.ts
+var active = null;
+function withValidationScope(run) {
+  if (active !== null) {
+    return run();
+  }
+  active = /* @__PURE__ */ new Map();
+  try {
+    return run();
+  } finally {
+    active = null;
+  }
+}
+function scopeCache(key, create) {
+  if (active === null) {
+    return void 0;
+  }
+  let value = active.get(key);
+  if (value === void 0) {
+    value = create();
+    active.set(key, value);
+  }
+  return value;
+}
+
+// src/scoring/dictation/normalize.ts
+var DICTATION_MAX_TRANSCRIPT_LENGTH = 2e3;
+var DICTATION_MAX_TEXT_LENGTH = 8e3;
+var DICTATION_MAX_EQUIVALENCE_LENGTH = 200;
+var DICTATION_MAX_EQUIVALENCES = 100;
+var DICTATION_MAX_ACCEPTED_TRANSCRIPTS = 10;
+var WORKING_LENGTH = 2 * DICTATION_MAX_TEXT_LENGTH;
+var UNSPACED_REVEAL_MIN_CHARACTERS = 4;
+var cp = (...points) => String.fromCodePoint(...points);
+var NEXT_LINE = cp(133);
+var MIDDLE_DOT = cp(183);
+var TIBETAN_TSHEG = cp(3851);
+var COMBINING_KEYCAP = cp(8419);
+var WAVING_BLACK_FLAG = 127988;
+var ZWNJ = 8204;
+var ZWJ = 8205;
+var MONGOLIAN_VOWEL_SEPARATOR = 6158;
+var JOINERS = cp(ZWNJ, ZWJ, MONGOLIAN_VOWEL_SEPARATOR);
+var MONGOLIAN_SELECTORS = cp(6155, 6156, 6157, 6159);
+var TAGS = `${cp(917536)}-${cp(917631)}`;
+var STRETCHERS = cp(1600, 2042);
+var COMPATIBILITY_RE = new RegExp(
+  `[${[
+    cp(170),
+    cp(178, 179, 181, 185, 186),
+    `${cp(188)}-${cp(190)}`,
+    `${cp(306)}-${cp(307)}`,
+    `${cp(319)}-${cp(320)}`,
+    cp(329),
+    `${cp(452)}-${cp(460)}`,
+    `${cp(497)}-${cp(499)}`,
+    `${cp(8304)}-${cp(8351)}`,
+    `${cp(8448)}-${cp(8591)}`,
+    `${cp(9312)}-${cp(9471)}`,
+    `${cp(11904)}-${cp(12255)}`,
+    `${cp(12881)}-${cp(12895)}`,
+    `${cp(12977)}-${cp(12991)}`,
+    `${cp(64256)}-${cp(65023)}`,
+    `${cp(65040)}-${cp(65049)}`,
+    `${cp(65072)}-${cp(65135)}`,
+    `${cp(65136)}-${cp(65278)}`,
+    `${cp(65281)}-${cp(65373)}`,
+    `${cp(65375)}-${cp(65506)}`,
+    `${cp(65508)}-${cp(65518)}`
+  ].join("")}]`,
+  "gu"
+);
+var COMPATIBILITY_JAMO = new Map(
+  Array.from({ length: 12686 - 12593 + 1 }, (_, index) => {
+    const jamo = cp(12593 + index);
+    return [jamo.normalize("NFKC"), jamo];
+  })
+);
+var SEQUENCE_FOLDS = /* @__PURE__ */ new Map([
+  [cp(3363, 3405, ZWJ), cp(3450)],
+  [cp(3368, 3405, ZWJ), cp(3451)],
+  [cp(3376, 3405, ZWJ), cp(3452)],
+  [cp(3378, 3405, ZWJ), cp(3453)],
+  [cp(3379, 3405, ZWJ), cp(3454)],
+  [cp(3349, 3405, ZWJ), cp(3455)],
+  [cp(3374, 3405, ZWJ), cp(3412)],
+  [cp(3375, 3405, ZWJ), cp(3413)],
+  [cp(3380, 3405, ZWJ), cp(3414)],
+  [cp(2468, 2509, ZWJ), cp(2510)],
+  [cp(3368, 3405, 3377), cp(3451, 3405, 3377)],
+  [cp(2352, 2381, ZWJ), cp(2353, 2381)],
+  [cp(2353, 2381, ZWJ), cp(2353, 2381)]
+]);
+var SEQUENCE_FOLDS_RE = new RegExp([...SEQUENCE_FOLDS.keys()].join("|"), "gu");
+var THAI_SARA_AM_PARTS_RE = new RegExp(
+  `${cp(3661)}([${cp(3656)}-${cp(3659)}]*)${cp(3634)}`,
+  "gu"
+);
+var LAO_SARA_AM_PARTS_RE = new RegExp(
+  `${cp(3789)}([${cp(3784)}-${cp(3787)}]*)${cp(3762)}`,
+  "gu"
+);
+function foldSequences(text) {
+  return text.replace(SEQUENCE_FOLDS_RE, (sequence) => SEQUENCE_FOLDS.get(sequence)).replace(THAI_SARA_AM_PARTS_RE, `$1${cp(3635)}`).replace(LAO_SARA_AM_PARTS_RE, `$1${cp(3763)}`);
+}
+var FOLDED = new Map(
+  [
+    [8216, "'"],
+    // LEFT SINGLE QUOTATION MARK
+    [8217, "'"],
+    // RIGHT SINGLE QUOTATION MARK (the smart apostrophe)
+    [8218, "'"],
+    // SINGLE LOW-9 QUOTATION MARK
+    [8219, "'"],
+    // SINGLE HIGH-REVERSED-9 QUOTATION MARK
+    [8242, "'"],
+    // PRIME
+    [700, "'"],
+    // MODIFIER LETTER APOSTROPHE
+    [180, "'"],
+    // ACUTE ACCENT, used as an apostrophe
+    [96, "'"],
+    // GRAVE ACCENT, used as an apostrophe
+    [1523, "'"],
+    // HEBREW PUNCTUATION GERESH
+    [8220, '"'],
+    // LEFT DOUBLE QUOTATION MARK
+    [8221, '"'],
+    // RIGHT DOUBLE QUOTATION MARK
+    [8222, '"'],
+    // DOUBLE LOW-9 QUOTATION MARK
+    [8243, '"'],
+    // DOUBLE PRIME
+    [1524, '"'],
+    // HEBREW PUNCTUATION GERSHAYIM
+    [8208, "-"],
+    // HYPHEN
+    [8209, "-"],
+    // NON-BREAKING HYPHEN
+    [1470, "-"],
+    // HEBREW PUNCTUATION MAQAF
+    [1418, "-"],
+    // ARMENIAN HYPHEN
+    [3852, TIBETAN_TSHEG],
+    // 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])
+);
+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)}`;
+var INVISIBLE_RE = new RegExp(
+  `(?![\\t\\n\\v\\f\\r${NEXT_LINE}${JOINERS}${MONGOLIAN_SELECTORS}${TAGS}${DRAWN_FORMAT_CHARACTERS}])[\\p{Cc}\\p{Cf}\\p{Default_Ignorable_Code_Point}${STRETCHERS}]`,
+  "gu"
+);
+var REPEATED_JOINER_RE = new RegExp(`([${JOINERS}])\\1+`, "gu");
+var LONE_SURROGATE_RE = /[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?<![\uD800-\uDBFF])[\uDC00-\uDFFF]/g;
+var REPLACEMENT_CHARACTER = cp(65533);
+var CONTEXTUAL_RE = new RegExp(`[${JOINERS}${MONGOLIAN_SELECTORS}${TAGS}]`, "u");
+var WHITESPACE_RE = new RegExp(`[\\s${NEXT_LINE}]+`, "gu");
+var UNSPACED_CLASS = "\\p{Script_Extensions=Han}\\p{Script_Extensions=Hiragana}\\p{Script_Extensions=Katakana}\\p{Script_Extensions=Thai}\\p{Script_Extensions=Lao}\\p{Script_Extensions=Khmer}\\p{Script_Extensions=Myanmar}";
+var UNSPACED_CHARACTER = `(?!\\p{Nd})[${UNSPACED_CLASS}]`;
+var IN_WORD_PUNCTUATION = `'\\-${MIDDLE_DOT}${TIBETAN_TSHEG}`;
+var PUNCTUATION_RE = new RegExp(
+  [
+    `[${IN_WORD_PUNCTUATION}](?<![\\p{L}\\p{M}\\p{N}][${IN_WORD_PUNCTUATION}])`,
+    `[${IN_WORD_PUNCTUATION}](?![\\p{L}\\p{M}\\p{N}])`,
+    `${MIDDLE_DOT}(?<=${UNSPACED_CHARACTER}${MIDDLE_DOT})`,
+    `${MIDDLE_DOT}(?=${UNSPACED_CHARACTER})`,
+    `(?![#*]${COMBINING_KEYCAP})[^\\P{P}${IN_WORD_PUNCTUATION}]`
+  ].join("|"),
+  "gu"
+);
+var ALL_PUNCTUATION_RE = new RegExp(`(?![#*]${COMBINING_KEYCAP})\\p{P}`, "gu");
+var DIGIT_SEPARATOR_RE = new RegExp(`(?<=\\p{N})[.,'${cp(1643, 1644)}](?=\\p{N})`, "gu");
+var UNSPACED_LETTERS_RE = new RegExp(`(?![\\p{M}\\p{Nd}])[${UNSPACED_CLASS}]`, "gu");
+var SPACE_BESIDE_UNSPACED_RE = new RegExp(
+  `(?<=${UNSPACED_CHARACTER}) (?=[\\p{L}\\p{M}\\p{N}])|(?<=[\\p{L}\\p{M}\\p{N}]) (?=${UNSPACED_CHARACTER})`,
+  "gu"
+);
+var WORD_RE = new RegExp(`^[\\p{L}\\p{M}\\p{N}${JOINERS}]$`, "u");
+var UNSPACED_CHARACTER_RE = new RegExp(`^${UNSPACED_CHARACTER}$`, "u");
+var EXTENDING_RE = new RegExp(`^[\\p{M}${JOINERS}${TAGS}]$`, "u");
+var WORD = 1;
+var UNSPACED = 2;
+var EXTENDING = 4;
+var KNOWN = 8;
+var FLAGS = [];
+function flagsOfCharacter(character) {
+  return KNOWN | (WORD_RE.test(character) ? WORD : 0) | (UNSPACED_CHARACTER_RE.test(character) ? UNSPACED : 0) | (EXTENDING_RE.test(character) ? EXTENDING : 0);
+}
+function flagsAt(text, index) {
+  const point = text.codePointAt(index);
+  let plane = FLAGS[point >> 16];
+  if (plane === void 0) {
+    plane = new Uint8Array(65536);
+    FLAGS[point >> 16] = plane;
+  }
+  const offset = point & 65535;
+  let flags = plane[offset];
+  if (flags === 0) {
+    flags = flagsOfCharacter(String.fromCodePoint(point));
+    plane[offset] = flags;
+  }
+  return flags;
+}
+var VIRAMAS = /* @__PURE__ */ new Set([
+  2381,
+  2509,
+  2637,
+  2765,
+  2893,
+  3021,
+  3149,
+  3277,
+  3387,
+  3388,
+  3405,
+  3530,
+  3642,
+  3770,
+  3972,
+  4153,
+  4154,
+  5908,
+  5909,
+  5940,
+  6098,
+  6752,
+  6980,
+  7082,
+  7083,
+  7154,
+  7155,
+  11647,
+  43014,
+  43052,
+  43204,
+  43347,
+  43456,
+  43766,
+  44013,
+  68159,
+  69702,
+  69744,
+  69759,
+  69817,
+  69939,
+  69940,
+  70080,
+  70197,
+  70378,
+  70477,
+  70606,
+  70607,
+  70608,
+  70722,
+  70850,
+  71103,
+  71231,
+  71350,
+  71467,
+  71737,
+  71997,
+  71998,
+  72160,
+  72244,
+  72263,
+  72345,
+  72767,
+  73028,
+  73029,
+  73111,
+  73537,
+  73538,
+  90415
+]);
+var JOINS_FORWARD = [
+  [1568, 1568],
+  [1574, 1574],
+  [1576, 1576],
+  [1578, 1582],
+  [1587, 1599],
+  [1601, 1607],
+  [1609, 1610],
+  [1646, 1647],
+  [1656, 1671],
+  [1690, 1727],
+  [1729, 1730],
+  [1740, 1740],
+  [1742, 1742],
+  [1744, 1745],
+  [1786, 1788],
+  [1791, 1791],
+  [1810, 1812],
+  [1818, 1821],
+  [1823, 1831],
+  [1833, 1833],
+  [1835, 1835],
+  [1837, 1838],
+  [1870, 1880],
+  [1884, 1898],
+  [1901, 1904],
+  [1906, 1906],
+  [1909, 1911],
+  [1914, 1919],
+  [1994, 2026],
+  [2113, 2117],
+  [2120, 2120],
+  [2122, 2131],
+  [2133, 2133],
+  [2144, 2144],
+  [2146, 2149],
+  [2152, 2152],
+  [2182, 2182],
+  [2185, 2189],
+  [2208, 2217],
+  [2223, 2224],
+  [2227, 2232],
+  [2234, 2248],
+  [6151, 6151],
+  [6176, 6264],
+  [6279, 6312],
+  [6314, 6314],
+  [43072, 43122],
+  [68288, 68292],
+  [68301, 68301],
+  [68307, 68316],
+  [68318, 68320],
+  [68331, 68334],
+  [68480, 68480],
+  [68482, 68482],
+  [68486, 68488],
+  [68490, 68491],
+  [68493, 68493],
+  [68496, 68496],
+  [68525, 68526],
+  [68864, 68897],
+  [68899, 68899],
+  [69315, 69316],
+  [69424, 69426],
+  [69428, 69444],
+  [69457, 69459],
+  [69488, 69491],
+  [69494, 69505],
+  [69552, 69552],
+  [69554, 69555],
+  [69560, 69560],
+  [69563, 69564],
+  [69566, 69567],
+  [69569, 69569],
+  [69572, 69572],
+  [69578, 69579],
+  [125184, 125251]
+];
+var JOINS_BACKWARD = [
+  [1568, 1568],
+  [1570, 1599],
+  [1601, 1610],
+  [1646, 1647],
+  [1649, 1651],
+  [1653, 1747],
+  [1749, 1749],
+  [1774, 1775],
+  [1786, 1788],
+  [1791, 1791],
+  [1808, 1808],
+  [1810, 1839],
+  [1869, 1919],
+  [1994, 2026],
+  [2112, 2136],
+  [2144, 2144],
+  [2146, 2149],
+  [2151, 2154],
+  [2160, 2178],
+  [2182, 2182],
+  [2185, 2190],
+  [2208, 2220],
+  [2222, 2248],
+  [6151, 6151],
+  [6176, 6264],
+  [6279, 6312],
+  [6314, 6314],
+  [43072, 43121],
+  [68288, 68293],
+  [68295, 68295],
+  [68297, 68298],
+  [68302, 68310],
+  [68312, 68321],
+  [68324, 68324],
+  [68331, 68335],
+  [68480, 68497],
+  [68521, 68526],
+  [68865, 68899],
+  [69314, 69316],
+  [69424, 69444],
+  [69457, 69460],
+  [69488, 69505],
+  [69552, 69552],
+  [69554, 69558],
+  [69560, 69567],
+  [69569, 69572],
+  [69577, 69578],
+  [125184, 125251]
+];
+var TRANSPARENT_RE = new RegExp(`^[\\p{Mn}\\p{Me}${cp(125259)}${TAGS}]$`, "u");
+function collapseWhitespace(text) {
+  return text.replace(WHITESPACE_RE, " ").trim();
+}
+function codePointLength(text) {
+  let length = 0;
+  for (const _ of text) {
+    length += 1;
+  }
+  return length;
+}
+function truncateCodePoints(text, max) {
+  if (text.length <= max) {
+    return text;
+  }
+  let points = 0;
+  let units = 0;
+  for (const character of text) {
+    if (points === max) {
+      return text.slice(0, units);
+    }
+    points += 1;
+    units += character.length;
+  }
+  return text;
+}
+function isLongerThan(text, max) {
+  if (text.length <= max) {
+    return false;
+  }
+  return text.length > 2 * max || truncateCodePoints(text, max).length < text.length;
+}
+function inRanges(point, ranges) {
+  return ranges.some(([first, last]) => point >= first && point <= last);
+}
+function isMongolianLetterOrMark(point) {
+  return point !== void 0 && point >= 6176 && point <= 6314;
+}
+function isMongolianSelector(point) {
+  return point !== void 0 && (point >= 6155 && point <= 6157 || point === 6159);
+}
+function letterBefore(points, index) {
+  for (let at = index - 1; at >= 0; at -= 1) {
+    const point = points[at];
+    if (!TRANSPARENT_RE.test(point)) {
+      return point.codePointAt(0);
+    }
+  }
+  return void 0;
+}
+function letterAfter(points, index) {
+  for (let at = index + 1; at < points.length; at += 1) {
+    const point = points[at];
+    if (!TRANSPARENT_RE.test(point)) {
+      return point.codePointAt(0);
+    }
+  }
+  return void 0;
+}
+var LETTER_OR_MARK_RE = /^[\p{L}\p{M}]$/u;
+function keepsInContext(points, index) {
+  const point = points[index].codePointAt(0);
+  const previous = points[index - 1];
+  const afterVirama = previous !== void 0 && VIRAMAS.has(previous.codePointAt(0));
+  if (point === ZWJ) {
+    const next = points[index + 1];
+    return afterVirama || previous !== void 0 && LETTER_OR_MARK_RE.test(previous) && next !== void 0 && VIRAMAS.has(next.codePointAt(0));
+  }
+  if (point === ZWNJ) {
+    if (afterVirama) {
+      return true;
+    }
+    const before = letterBefore(points, index);
+    const after = letterAfter(points, index);
+    return before !== void 0 && after !== void 0 && inRanges(before, JOINS_FORWARD) && inRanges(after, JOINS_BACKWARD);
+  }
+  const previousPoint = previous?.codePointAt(0);
+  if (point === MONGOLIAN_VOWEL_SEPARATOR) {
+    return (isMongolianLetterOrMark(previousPoint) || isMongolianSelector(previousPoint)) && isMongolianLetterOrMark(points[index + 1]?.codePointAt(0));
+  }
+  return isMongolianLetterOrMark(previousPoint);
+}
+function settle(text) {
+  let current = text;
+  for (; ; ) {
+    let next = foldSequences(current);
+    if (CONTEXTUAL_RE.test(next)) {
+      const points = Array.from(next.replace(REPEATED_JOINER_RE, "$1"));
+      let inFlag = false;
+      next = points.filter((character, index) => {
+        const point = character.codePointAt(0);
+        if (point >= 917536 && point <= 917631) {
+          return inFlag;
+        }
+        inFlag = point === WAVING_BLACK_FLAG;
+        return !CONTEXTUAL_RE.test(character) || keepsInContext(points, index);
+      }).join("");
+    }
+    next = collapseWhitespace(next).normalize("NFC");
+    if (next === current) {
+      return current;
+    }
+    current = next;
+  }
+}
+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);
+  if (carried === null) {
+    return COMPATIBILITY_JAMO.get(folded) ?? folded;
+  }
+  return PUNCTUATION_CHARACTER_RE.test(character) || offset === 0 || SPACING_CHARACTER_RE.test(text.charAt(offset - 1)) ? character : carried[1];
+}
+function preStripNormalize(text) {
+  return settle(
+    collapseWhitespace(
+      text.replace(LONE_SURROGATE_RE, REPLACEMENT_CHARACTER).normalize("NFC").replace(COMPATIBILITY_RE, foldCompatibility).replace(INVISIBLE_RE, "").replace(FOLDED_RE, (character) => FOLDED.get(character)).toLowerCase()
+    ).normalize("NFC")
+  );
+}
+function settleWithout(text, pattern, replacement) {
+  let current = text;
+  for (; ; ) {
+    const next = settle(current.replace(pattern, replacement));
+    if (next === current) {
+      return current;
+    }
+    current = next;
+  }
+}
+function stripPunctuation(text) {
+  return settleWithout(text, PUNCTUATION_RE, "");
+}
+function spacePunctuation(text) {
+  return settleWithout(text.replace(DIGIT_SEPARATOR_RE, ""), ALL_PUNCTUATION_RE, " ");
+}
+function isHighSurrogate(unit) {
+  return unit >= 55296 && unit <= 56319;
+}
+function isLowSurrogate(unit) {
+  return unit >= 56320 && unit <= 57343;
+}
+function startOfCodePointBefore(text, index) {
+  return index >= 2 && isLowSurrogate(text.charCodeAt(index - 1)) && isHighSurrogate(text.charCodeAt(index - 2)) ? index - 2 : index - 1;
+}
+function lastCodePointAfter(previous, appended) {
+  return appended === "" ? previous : appended.slice(startOfCodePointBefore(appended, appended.length));
+}
+function isAsciiWordUnit(unit) {
+  return unit >= 48 && unit <= 57 || unit >= 97 && unit <= 122;
+}
+function isWordAt(text, index) {
+  const unit = text.charCodeAt(index);
+  return unit < 128 ? isAsciiWordUnit(unit) : (flagsAt(text, index) & WORD) !== 0;
+}
+function isSpacedWordAt(text, index) {
+  const unit = text.charCodeAt(index);
+  return unit < 128 ? isAsciiWordUnit(unit) : (flagsAt(text, index) & (WORD | UNSPACED)) === WORD;
+}
+function isExtendingAt(text, index) {
+  return text.charCodeAt(index) >= 128 && (flagsAt(text, index) & EXTENDING) !== 0;
+}
+function edgeOf(text, index, unspaced) {
+  if (!isWordAt(text, index)) {
+    return "none";
+  }
+  return isSpacedWordAt(text, index) ? "spaced" : unspaced;
+}
+function phraseOf(text, unspaced) {
+  return {
+    text,
+    before: edgeOf(text, 0, unspaced),
+    after: edgeOf(text, startOfCodePointBefore(text, text.length), unspaced)
+  };
+}
+function blocks(edge, text, neighbour) {
+  if (edge === "none") {
+    return false;
+  }
+  return edge === "spaced" ? isSpacedWordAt(text, neighbour) : isWordAt(text, neighbour);
+}
+function isMatchAt(text, phrase, at) {
+  const end = at + phrase.text.length;
+  if (end < text.length && (isExtendingAt(text, end) || blocks(phrase.after, text, end))) {
+    return false;
+  }
+  return !(at > 0 && blocks(phrase.before, text, startOfCodePointBefore(text, at)));
+}
+function indexOfPhrase(text, phrase, start) {
+  const needle = phrase.text;
+  let at = text.indexOf(needle, start);
+  while (at !== -1) {
+    if (phrase.before === "spaced" && at > 0 && isSpacedWordAt(text, startOfCodePointBefore(text, at))) {
+      let next = at;
+      while (next < text.length && isSpacedWordAt(text, next)) {
+        next += isHighSurrogate(text.charCodeAt(next)) && isLowSurrogate(text.charCodeAt(next + 1)) ? 2 : 1;
+      }
+      at = text.indexOf(needle, next);
+      continue;
+    }
+    if (isMatchAt(text, phrase, at)) {
+      return at;
+    }
+    at = text.indexOf(needle, at + 1);
+  }
+  return -1;
+}
+function containsPhrase(text, phrase) {
+  const needle = phrase.text;
+  const length = needle.length;
+  if (length === 0 || length > text.length) {
+    return false;
+  }
+  const fallback = new Int32Array(length);
+  for (let index = 1, matched = 0; index < length; index += 1) {
+    while (matched > 0 && needle.charCodeAt(index) !== needle.charCodeAt(matched)) {
+      matched = fallback[matched - 1];
+    }
+    if (needle.charCodeAt(index) === needle.charCodeAt(matched)) {
+      matched += 1;
+    }
+    fallback[index] = matched;
+  }
+  for (let index = 0, matched = 0; index < text.length; index += 1) {
+    while (matched > 0 && text.charCodeAt(index) !== needle.charCodeAt(matched)) {
+      matched = fallback[matched - 1];
+    }
+    if (text.charCodeAt(index) === needle.charCodeAt(matched)) {
+      matched += 1;
+    }
+    if (matched === length) {
+      if (isMatchAt(text, phrase, index - length + 1)) {
+        return true;
+      }
+      matched = fallback[matched - 1];
+    }
+  }
+  return false;
+}
+function compileRules(tolerance) {
+  const equivalences = tolerance?.equivalences;
+  if (!Array.isArray(equivalences)) {
+    return { rules: [], signature: "[]" };
+  }
+  const rules = [];
+  for (const rule of equivalences.slice(0, DICTATION_MAX_EQUIVALENCES)) {
+    const rawFrom = rule?.from;
+    const rawTo = rule?.to;
+    if (typeof rawFrom !== "string" || typeof rawTo !== "string" || isLongerThan(rawFrom, DICTATION_MAX_EQUIVALENCE_LENGTH) || isLongerThan(rawTo, DICTATION_MAX_EQUIVALENCE_LENGTH)) {
+      continue;
+    }
+    const from = preStripNormalize(rawFrom);
+    const to = stripPunctuation(preStripNormalize(rawTo));
+    if (from === "" || to === "") {
+      continue;
+    }
+    rules.push({
+      from: phraseOf(from, "none"),
+      to,
+      spaceBefore: isSpacedWordAt(to, 0),
+      spaceAfter: isSpacedWordAt(to, startOfCodePointBefore(to, to.length))
+    });
+  }
+  return {
+    rules,
+    signature: JSON.stringify(rules.map((rule) => [rule.from.text, rule.to]))
+  };
+}
+function bounded(text) {
+  return isLongerThan(text, WORKING_LENGTH) ? { text: truncateCodePoints(text, WORKING_LENGTH), cut: true } : { text, cut: false };
+}
+function rewrite(text, rule) {
+  let output = "";
+  let consumed = 0;
+  let last = "";
+  for (let at = indexOfPhrase(text, rule.from, 0); at !== -1; at = indexOfPhrase(text, rule.from, consumed)) {
+    const between = text.slice(consumed, at);
+    if (rule.spaceAfter && consumed > 0 && between !== "" && isSpacedWordAt(between, 0)) {
+      output += " ";
+    }
+    output += between;
+    last = lastCodePointAfter(last, between);
+    if (rule.spaceBefore && last !== "" && isSpacedWordAt(last, 0)) {
+      output += " ";
+      last = " ";
+    }
+    output += rule.to;
+    last = lastCodePointAfter(last, rule.to);
+    consumed = at + rule.from.text.length;
+    if (output.length > 2 * WORKING_LENGTH) {
+      return { text: truncateCodePoints(output, WORKING_LENGTH), cut: true };
+    }
+  }
+  const rest = text.slice(consumed);
+  const apart = rule.spaceAfter && consumed > 0 && rest !== "" && isSpacedWordAt(rest, 0);
+  return bounded(apart ? `${output} ${rest}` : output + rest);
+}
+var WORKING_TEXTS = /* @__PURE__ */ Symbol("dictation working texts");
+var MEASURED_TRANSCRIPTS = /* @__PURE__ */ Symbol("dictation measured transcripts");
+var SHOWN_TEXTS = /* @__PURE__ */ Symbol("dictation shown texts");
+var REVEALS = /* @__PURE__ */ Symbol("dictation reveal answers");
+function scopedMap(key, signature) {
+  const bySignature = scopeCache(key, () => /* @__PURE__ */ new Map());
+  if (bySignature === void 0) {
+    return /* @__PURE__ */ new Map();
+  }
+  let map = bySignature.get(signature);
+  if (map === void 0) {
+    map = /* @__PURE__ */ new Map();
+    bySignature.set(signature, map);
+  }
+  return map;
+}
+var PRE_STRIP_TEXTS = /* @__PURE__ */ Symbol("dictation pre-strip texts");
+function boundedPreStrip(text) {
+  const memo = scopeCache(PRE_STRIP_TEXTS, () => /* @__PURE__ */ new Map());
+  let result = memo?.get(text);
+  if (result === void 0) {
+    result = bounded(preStripNormalize(text));
+    memo?.set(text, result);
+  }
+  return result;
+}
+function isBlankBeforeRules(text) {
+  return boundedPreStrip(text).text === "";
+}
+function workingText(text, compiled, preStripped = boundedPreStrip(text)) {
+  if (compiled.rules.length === 0) {
+    return preStripped;
+  }
+  const memo = scopeCache(WORKING_TEXTS, () => /* @__PURE__ */ new Map());
+  let known = memo?.get(compiled.signature);
+  const remembered = known?.get(text);
+  if (remembered !== void 0) {
+    return remembered;
+  }
+  let working = preStripped;
+  let cut = working.cut;
+  for (const rule of compiled.rules) {
+    working = rewrite(working.text, rule);
+    cut ||= working.cut;
+  }
+  const result = { text: working.text, cut };
+  if (memo !== void 0) {
+    if (known === void 0) {
+      known = /* @__PURE__ */ new Map();
+      memo.set(compiled.signature, known);
+    }
+    known.set(text, result);
+  }
+  return result;
+}
+function normalizeDictationTextBounded(text, tolerance) {
+  const working = workingText(text, compileRules(tolerance));
+  return { text: stripPunctuation(working.text), cut: working.cut };
+}
+function normalizeDictationText(text, tolerance) {
+  return normalizeDictationTextBounded(text, tolerance).text;
+}
+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);
+  const workingStripped = stripForReveal(working);
+  const source = writtenStripped === "" ? workingStripped : writtenStripped;
+  if (source === "") {
+    return NOTHING_TO_REVEAL;
+  }
+  const long = (source.match(UNSPACED_LETTERS_RE)?.length ?? 0) >= UNSPACED_REVEAL_MIN_CHARACTERS;
+  const { before, after } = phraseOf(source, long ? "none" : "visible");
+  const forms = [
+    writtenStripped,
+    spacePunctuation(written),
+    workingStripped,
+    spacePunctuation(working)
+  ].map((form) => long ? form.replace(SPACE_BESIDE_UNSPACED_RE, "") : form);
+  return { forms: [...new Set(forms)].filter((form) => form !== ""), long, before, after };
+}
+function dictationNormalizer(tolerance) {
+  const compiled = compileRules(tolerance);
+  const measured = scopedMap(MEASURED_TRANSCRIPTS, compiled.signature);
+  const shownTexts = scopedMap(SHOWN_TEXTS, compiled.signature);
+  return {
+    measure(text) {
+      let result = measured.get(text);
+      if (result === void 0) {
+        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 normalized = stripPunctuation(working.text);
+          result = {
+            tooLong: working.cut || isLongerThan(normalized, DICTATION_MAX_TRANSCRIPT_LENGTH),
+            normalized,
+            reveal: readingOf(written.text, working.text)
+          };
+        }
+        measured.set(text, result);
+      }
+      return result;
+    },
+    shown(text) {
+      let result = shownTexts.get(text);
+      if (result === void 0) {
+        const plainText = isLongerThan(text, WORKING_LENGTH) ? null : boundedPreStrip(text);
+        const working = plainText === null ? null : workingText(text, compiled, plainText);
+        if (plainText === null || working === null || working.cut) {
+          result = { tooLong: true, forms: [] };
+        } else {
+          const plain = plainText.text;
+          result = {
+            tooLong: false,
+            forms: [
+              .../* @__PURE__ */ new Set([
+                stripForReveal(working.text),
+                spacePunctuation(working.text),
+                stripForReveal(plain),
+                spacePunctuation(plain)
+              ])
+            ]
+          };
+        }
+        shownTexts.set(text, result);
+      }
+      return result;
+    }
+  };
+}
+function revealsCandidate(forms, candidate) {
+  const memo = scopeCache(REVEALS, () => /* @__PURE__ */ new WeakMap());
+  const known = memo?.get(forms)?.get(candidate);
+  if (known !== void 0) {
+    return known;
+  }
+  const answer = searchReveal(forms, candidate);
+  if (memo !== void 0) {
+    const byCandidate = memo.get(forms) ?? /* @__PURE__ */ new WeakMap();
+    byCandidate.set(candidate, answer);
+    memo.set(forms, byCandidate);
+  }
+  return answer;
+}
+var COMPACTED_FORMS = /* @__PURE__ */ new WeakMap();
+function searchReveal(forms, candidate) {
+  const { reveal } = candidate;
+  if (candidate.tooLong) {
+    return false;
+  }
+  let fields = forms;
+  if (reveal.long) {
+    fields = COMPACTED_FORMS.get(forms) ?? forms.map((form) => form.replace(SPACE_BESIDE_UNSPACED_RE, ""));
+    COMPACTED_FORMS.set(forms, fields);
+  }
+  return reveal.forms.some((text) => {
+    const phrase = { text, before: reveal.before, after: reveal.after };
+    return fields.some((field) => containsPhrase(field, phrase));
+  });
+}
+
 // src/schemas/feedback.ts
 import { z } from "zod/v4";
 var FeedbackSchema = z.looseObject({
@@ -136,47 +1006,264 @@ var RedactedMediaSchema = z2.strictObject({
   path: ["url"]
 });
 
-// src/schemas/fill-in-the-blanks.ts
+// src/schemas/dictation.ts
 import { z as z3 } from "zod/v4";
-var PLACEHOLDER_RE = /\{\{\s*([^{}]+?)\s*\}\}/g;
-var TextMatchPolicySchema = z3.looseObject({
-  caseSensitive: z3.boolean().optional(),
-  trim: z3.boolean().optional(),
-  normalize: z3.enum(["none", "NFC", "NFKC"]).optional(),
-  foldDiacritics: z3.boolean().optional(),
-  collapseInnerWhitespace: z3.boolean().optional(),
-  ignorePunctuation: z3.boolean().optional(),
-  levenshtein: z3.number().int().min(0).optional(),
-  locale: z3.string().optional()
+var DictationSlowMediaSchema = z3.looseObject({
+  type: z3.literal("audio"),
+  url: MediaUrlSchema,
+  alt: z3.string().min(1).optional()
 });
-var BlankConfigSchema = z3.looseObject({
-  id: z3.string().min(1),
-  acceptedAnswers: z3.array(
-    z3.string().min(1).refine((answer) => answer.trim().length > 0, {
-      error: "Accepted answers must contain non-whitespace characters."
-    })
-  ).min(1),
-  caseSensitive: z3.boolean().optional(),
-  trimWhitespace: z3.boolean().optional(),
-  match: TextMatchPolicySchema.optional(),
-  hint: z3.string().optional(),
-  feedback: z3.string().optional()
+var RuleTextSchema = z3.string().min(1).meta({ maxLength: DICTATION_MAX_EQUIVALENCE_LENGTH });
+var TranscriptTextSchema = z3.string().min(1).meta({ maxLength: DICTATION_MAX_TRANSCRIPT_LENGTH });
+var DictationEquivalenceSchema = z3.looseObject({
+  from: RuleTextSchema,
+  to: RuleTextSchema
+}).refine((rule) => codePointLength(rule.from) <= DICTATION_MAX_EQUIVALENCE_LENGTH, {
+  error: `A rule rewrites at most ${DICTATION_MAX_EQUIVALENCE_LENGTH} characters.`,
+  path: ["from"]
+}).refine((rule) => codePointLength(rule.to) <= DICTATION_MAX_EQUIVALENCE_LENGTH, {
+  error: `A rewrite is at most ${DICTATION_MAX_EQUIVALENCE_LENGTH} characters.`,
+  path: ["to"]
+});
+var DictationToleranceSchema = z3.looseObject({
+  equivalences: z3.array(DictationEquivalenceSchema).max(DICTATION_MAX_EQUIVALENCES, {
+    error: `A dictation carries at most ${DICTATION_MAX_EQUIVALENCES} equivalence rules.`
+  }).optional()
 });
-var FillInTheBlanksDataSchema = z3.looseObject({
+var normalizers = /* @__PURE__ */ new WeakMap();
+function normalizerFor(data) {
+  let normalizer = normalizers.get(data);
+  if (normalizer === void 0) {
+    normalizer = dictationNormalizer(data.tolerance);
+    normalizers.set(data, normalizer);
+  }
+  return normalizer;
+}
+function measure(data, text) {
+  return normalizerFor(data).measure(text);
+}
+function candidatesOf(data) {
+  return [data.transcript, ...data.acceptedTranscripts ?? []];
+}
+function isEmpty(measured) {
+  return measured.normalized === "";
+}
+function checkEvenAfterIssues(check) {
+  const guard = new z3.core.$ZodCheck({ check: "custom", when: () => true });
+  guard._zod.check = check;
+  return guard;
+}
+var DictationDataShape = z3.looseObject({
   schemaVersion: z3.literal("1.0"),
-  type: z3.literal("fill-in-the-blanks"),
+  type: z3.literal("dictation"),
   id: z3.string().min(1),
   title: z3.string().min(1),
-  passage: z3.string().min(1),
-  passageHtml: z3.string().optional(),
-  blanks: z3.array(BlankConfigSchema).min(1),
-  scoringStrategy: z3.enum(["all-or-nothing", "partial"]),
+  transcript: TranscriptTextSchema,
+  acceptedTranscripts: z3.array(TranscriptTextSchema).max(DICTATION_MAX_ACCEPTED_TRANSCRIPTS).optional(),
   media: MediaSchema.optional(),
+  slowMedia: DictationSlowMediaSchema.optional(),
+  hints: z3.looseObject({ mode: z3.literal("progressive-words") }).optional(),
+  tolerance: DictationToleranceSchema.optional(),
   feedback: FeedbackSchema.optional(),
   passThreshold: z3.number().min(0).max(1).optional(),
   locale: z3.string().optional(),
   learningObjectives: z3.array(z3.string()).optional(),
   difficultyLevel: z3.literal([1, 2, 3, 4, 5]).optional()
+});
+var DictationDataSchema = DictationDataShape.check(
+  checkEvenAfterIssues((ctx) => {
+    if (ctx.issues.some((issue2) => (issue2.path?.length ?? 0) === 0)) {
+      return;
+    }
+    const data = ctx.value;
+    const refused = new Set(ctx.issues.map((issue2) => String(issue2.path?.[0])));
+    const report = (path, input, message) => {
+      ctx.issues.push({ code: "custom", input, message, path: [...path] });
+    };
+    const rulesParse = !refused.has("tolerance");
+    const transcriptParses = !refused.has("transcript");
+    if (rulesParse && transcriptParses) {
+      const transcript = measure(data, data.transcript);
+      if (isEmpty(transcript)) {
+        report(
+          ["transcript"],
+          data.transcript,
+          "The transcript must contain something to type: after ignoring case, punctuation and spacing nothing is left."
+        );
+      }
+      if (transcript.tooLong) {
+        report(
+          ["transcript"],
+          data.transcript,
+          `A transcript is at most ${DICTATION_MAX_TRANSCRIPT_LENGTH} characters, before and after its equivalences are applied, and its equivalences may not grow it past ${WORKING_LENGTH} characters on the way.`
+        );
+      }
+      if (!refused.has("acceptedTranscripts")) {
+        const accepted = data.acceptedTranscripts ?? [];
+        if (accepted.some((entry) => {
+          const measured = measure(data, entry);
+          return measured.tooLong || isEmpty(measured);
+        })) {
+          report(
+            ["acceptedTranscripts"],
+            data.acceptedTranscripts,
+            `An accepted transcript must contain something to type and be at most ${DICTATION_MAX_TRANSCRIPT_LENGTH} characters, before and after its equivalences are applied, and its equivalences may not grow it past ${WORKING_LENGTH} characters on the way.`
+          );
+        }
+        const normalized = candidatesOf(data).map((entry) => measure(data, entry).normalized).filter((entry) => entry !== null);
+        if (new Set(normalized).size !== normalized.length) {
+          report(
+            ["acceptedTranscripts"],
+            data.acceptedTranscripts,
+            "An accepted transcript must differ from the transcript and from the other accepted transcripts once case, punctuation and spacing are ignored."
+          );
+        }
+      }
+    }
+    const mediaParses = !refused.has("media");
+    const slowParses = !refused.has("slowMedia");
+    if (mediaParses && data.media !== void 0 && data.media.type !== "audio") {
+      report(
+        ["media", "type"],
+        data.media.type,
+        "A dictation is dictated: its recording must be audio."
+      );
+    }
+    if (slowParses && data.slowMedia?.playback !== void 0) {
+      report(
+        ["slowMedia", "playback"],
+        data.slowMedia.playback,
+        "The slow recording carries no playback policy of its own; put the policy on `media` \u2014 the slow recording follows it (except the play budget)."
+      );
+    }
+    if (mediaParses && slowParses && data.slowMedia !== void 0) {
+      if (data.media?.playback?.maxPlays !== void 0) {
+        report(
+          ["slowMedia"],
+          data.slowMedia,
+          "A play budget on `media` cannot coexist with an unbudgeted slow recording of the same content. Drop `slowMedia`, or drop `maxPlays` (a budgeted recording can still offer the transport's 0.75\xD7 speed when `rate` is `allow`)."
+        );
+      }
+      if (typeof data.slowMedia.url === "string" && typeof data.media?.url === "string" && data.slowMedia.url === data.media.url) {
+        report(
+          ["slowMedia", "url"],
+          data.slowMedia.url,
+          "The slow recording must be a different file from the recording."
+        );
+      }
+      if (data.media === void 0) {
+        report(
+          ["media"],
+          data.media,
+          "A slow recording accompanies a recording: add `media` first."
+        );
+      }
+    }
+    if (rulesParse && !(data.tolerance?.equivalences ?? []).every(
+      (rule) => preStripNormalize(rule.from) !== "" && normalizeDictationText(rule.to) !== ""
+    )) {
+      report(
+        ["tolerance", "equivalences"],
+        data.tolerance?.equivalences,
+        "An equivalence must name a word, phrase or symbol to rewrite, and rewrite it to something that survives normalisation (not only punctuation or spaces)."
+      );
+    }
+    for (const field of ["media", "slowMedia"]) {
+      const recording = data[field];
+      if (recording?.captionsUrl !== void 0) {
+        report(
+          [field, "captionsUrl"],
+          recording.captionsUrl,
+          "A dictation recording cannot carry captions: the captions are the answer. Offer an accessible alternative as a different item."
+        );
+      }
+    }
+    if (!rulesParse || !transcriptParses) {
+      return;
+    }
+    const normalizer = normalizerFor(data);
+    const candidates = candidatesOf(data).map((entry) => normalizer.measure(entry));
+    const shown = [
+      [["title"], refused.has("title") ? void 0 : data.title],
+      [["media", "alt"], data.media?.alt],
+      [["slowMedia", "alt"], data.slowMedia?.alt]
+    ];
+    for (const [path, value] of shown) {
+      if (value === void 0) {
+        continue;
+      }
+      const { tooLong, forms } = normalizer.shown(value);
+      if (tooLong) {
+        report(
+          path,
+          value,
+          `The title and the recording descriptions are searched for the transcript before they are shown: each is at most ${WORKING_LENGTH} characters, before and after the equivalences are applied, and the equivalences may not grow it past that on the way.`
+        );
+      } else if (candidates.some((candidate) => revealsCandidate(forms, candidate))) {
+        report(
+          path,
+          value,
+          'The title and the recording descriptions are shown to the learner before they type: they must not contain the transcript. Describe the recording ("Recording, normal speed"), never transcribe it.'
+        );
+      }
+    }
+  })
+);
+function groupCaptionsRevealDictation(group, hasCaptions = (captionsUrl) => captionsUrl !== void 0) {
+  const isObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+  if (!isObject(group) || !isObject(group.stimulus) || !isObject(group.stimulus.media)) {
+    return false;
+  }
+  if (!hasCaptions(group.stimulus.media.captionsUrl) || !Array.isArray(group.items)) {
+    return false;
+  }
+  return group.items.some(
+    (item) => isObject(item) && item.type === "dictation" && item.media === void 0
+  );
+}
+var GROUP_CAPTIONS_REVEAL_DICTATION = "The stimulus recording carries captions, and a dictation in this group plays that recording: the captions are the answer. Remove the captions, or give the dictation its own recording.";
+
+// src/schemas/fill-in-the-blanks.ts
+import { z as z4 } from "zod/v4";
+var PLACEHOLDER_RE = /\{\{\s*([^{}]+?)\s*\}\}/g;
+var TextMatchPolicySchema = z4.looseObject({
+  caseSensitive: z4.boolean().optional(),
+  trim: z4.boolean().optional(),
+  normalize: z4.enum(["none", "NFC", "NFKC"]).optional(),
+  foldDiacritics: z4.boolean().optional(),
+  collapseInnerWhitespace: z4.boolean().optional(),
+  ignorePunctuation: z4.boolean().optional(),
+  levenshtein: z4.number().int().min(0).optional(),
+  locale: z4.string().optional()
+});
+var BlankConfigSchema = z4.looseObject({
+  id: z4.string().min(1),
+  acceptedAnswers: z4.array(
+    z4.string().min(1).refine((answer) => answer.trim().length > 0, {
+      error: "Accepted answers must contain non-whitespace characters."
+    })
+  ).min(1),
+  caseSensitive: z4.boolean().optional(),
+  trimWhitespace: z4.boolean().optional(),
+  match: TextMatchPolicySchema.optional(),
+  hint: z4.string().optional(),
+  feedback: z4.string().optional()
+});
+var FillInTheBlanksDataSchema = z4.looseObject({
+  schemaVersion: z4.literal("1.0"),
+  type: z4.literal("fill-in-the-blanks"),
+  id: z4.string().min(1),
+  title: z4.string().min(1),
+  passage: z4.string().min(1),
+  passageHtml: z4.string().optional(),
+  blanks: z4.array(BlankConfigSchema).min(1),
+  scoringStrategy: z4.enum(["all-or-nothing", "partial"]),
+  media: MediaSchema.optional(),
+  feedback: FeedbackSchema.optional(),
+  passThreshold: z4.number().min(0).max(1).optional(),
+  locale: z4.string().optional(),
+  learningObjectives: z4.array(z4.string()).optional(),
+  difficultyLevel: z4.literal([1, 2, 3, 4, 5]).optional()
 }).refine(
   (data) => {
     const placeholderCounts2 = /* @__PURE__ */ new Map();
@@ -200,14 +1287,14 @@ var FillInTheBlanksDataSchema = z3.looseObject({
 );
 
 // src/schemas/multiple-choice.ts
-import { z as z4 } from "zod/v4";
-var MultipleChoiceOptionMediaSchema = z4.looseObject({
+import { z as z5 } from "zod/v4";
+var MultipleChoiceOptionMediaSchema = z5.looseObject({
   // No `embed`: an iframe swallows the click that selects the option, so the
   // learner could not choose it. No `video`: a native control bar inside the
   // option's label eats the same click.
-  type: z4.enum(["image", "audio"]),
+  type: z5.enum(["image", "audio"]),
   url: MediaUrlSchema,
-  alt: z4.string().min(1).optional(),
+  alt: z5.string().min(1).optional(),
   captionsUrl: MediaUrlSchema.optional()
 }).refine((media) => media.type !== "image" || media.alt !== void 0 && media.alt !== "", {
   error: "An image option requires a non-empty `alt`.",
@@ -216,30 +1303,30 @@ var MultipleChoiceOptionMediaSchema = z4.looseObject({
   error: "An option carries no playback policy. maxPlays, seek and rate are enforced only on the media above the question.",
   path: ["playback"]
 });
-var MultipleChoiceOptionSchema = z4.looseObject({
-  id: z4.string().min(1),
-  text: z4.string().min(1),
-  isCorrect: z4.boolean(),
-  feedback: z4.string().optional(),
+var MultipleChoiceOptionSchema = z5.looseObject({
+  id: z5.string().min(1),
+  text: z5.string().min(1),
+  isCorrect: z5.boolean(),
+  feedback: z5.string().optional(),
   media: MultipleChoiceOptionMediaSchema.optional()
 });
-var MultipleChoiceDataSchema = z4.looseObject({
-  schemaVersion: z4.literal("1.0"),
-  type: z4.literal("multiple-choice"),
-  id: z4.string().min(1),
-  title: z4.string().min(1),
-  question: z4.string().min(1),
-  questionHtml: z4.string().optional(),
-  mode: z4.enum(["single", "multi"]),
-  options: z4.array(MultipleChoiceOptionSchema).min(2).max(26),
-  scoringStrategy: z4.enum(["all-or-nothing", "partial"]),
+var MultipleChoiceDataSchema = z5.looseObject({
+  schemaVersion: z5.literal("1.0"),
+  type: z5.literal("multiple-choice"),
+  id: z5.string().min(1),
+  title: z5.string().min(1),
+  question: z5.string().min(1),
+  questionHtml: z5.string().optional(),
+  mode: z5.enum(["single", "multi"]),
+  options: z5.array(MultipleChoiceOptionSchema).min(2).max(26),
+  scoringStrategy: z5.enum(["all-or-nothing", "partial"]),
   media: MediaSchema.optional(),
   feedback: FeedbackSchema.optional(),
-  passThreshold: z4.number().min(0).max(1).optional(),
-  shuffle: z4.boolean().optional(),
-  locale: z4.string().optional(),
-  learningObjectives: z4.array(z4.string()).optional(),
-  difficultyLevel: z4.literal([1, 2, 3, 4, 5]).optional()
+  passThreshold: z5.number().min(0).max(1).optional(),
+  shuffle: z5.boolean().optional(),
+  locale: z5.string().optional(),
+  learningObjectives: z5.array(z5.string()).optional(),
+  difficultyLevel: z5.literal([1, 2, 3, 4, 5]).optional()
 }).refine((data) => data.options.some((option) => option.isCorrect), {
   error: "At least one option must be marked correct.",
   path: ["options"]
@@ -267,21 +1354,21 @@ function countWords(text) {
 }
 
 // src/schemas/gap-select.ts
-import { z as z5 } from "zod/v4";
-var GapSelectChoiceSchema = z5.looseObject({
-  id: z5.string().min(1),
-  text: z5.string().min(1)
+import { z as z6 } from "zod/v4";
+var GapSelectChoiceSchema = z6.looseObject({
+  id: z6.string().min(1),
+  text: z6.string().min(1)
 });
-var GapSelectBankSchema = z5.looseObject({
-  id: z5.string().min(1),
-  choices: z5.array(GapSelectChoiceSchema).min(2)
+var GapSelectBankSchema = z6.looseObject({
+  id: z6.string().min(1),
+  choices: z6.array(GapSelectChoiceSchema).min(2)
 });
-var GapSelectGapSchema = z5.looseObject({
-  id: z5.string().min(1),
-  choices: z5.array(GapSelectChoiceSchema).min(2).optional(),
-  bankId: z5.string().min(1).optional(),
-  correctChoiceId: z5.string().min(1),
-  feedback: z5.string().optional()
+var GapSelectGapSchema = z6.looseObject({
+  id: z6.string().min(1),
+  choices: z6.array(GapSelectChoiceSchema).min(2).optional(),
+  bankId: z6.string().min(1).optional(),
+  correctChoiceId: z6.string().min(1),
+  feedback: z6.string().optional()
 });
 function resolveChoices(gap, banks) {
   if (gap.choices !== void 0) {
@@ -300,24 +1387,24 @@ function placeholderCounts(passage) {
   }
   return counts;
 }
-var GapSelectDataSchema = z5.looseObject({
-  schemaVersion: z5.literal("1.0"),
-  type: z5.literal("gap-select"),
-  id: z5.string().min(1),
-  title: z5.string().min(1),
-  passage: z5.string().min(1),
-  passageHtml: z5.string().optional(),
-  gaps: z5.array(GapSelectGapSchema).min(1),
-  banks: z5.array(GapSelectBankSchema).optional(),
-  scoringStrategy: z5.enum(["all-or-nothing", "partial"]),
-  presentation: z5.literal("dropdown").optional(),
-  shuffleChoices: z5.boolean().optional(),
+var GapSelectDataSchema = z6.looseObject({
+  schemaVersion: z6.literal("1.0"),
+  type: z6.literal("gap-select"),
+  id: z6.string().min(1),
+  title: z6.string().min(1),
+  passage: z6.string().min(1),
+  passageHtml: z6.string().optional(),
+  gaps: z6.array(GapSelectGapSchema).min(1),
+  banks: z6.array(GapSelectBankSchema).optional(),
+  scoringStrategy: z6.enum(["all-or-nothing", "partial"]),
+  presentation: z6.literal("dropdown").optional(),
+  shuffleChoices: z6.boolean().optional(),
   media: MediaSchema.optional(),
   feedback: FeedbackSchema.optional(),
-  passThreshold: z5.number().min(0).max(1).optional(),
-  locale: z5.string().optional(),
-  learningObjectives: z5.array(z5.string()).optional(),
-  difficultyLevel: z5.literal([1, 2, 3, 4, 5]).optional()
+  passThreshold: z6.number().min(0).max(1).optional(),
+  locale: z6.string().optional(),
+  learningObjectives: z6.array(z6.string()).optional(),
+  difficultyLevel: z6.literal([1, 2, 3, 4, 5]).optional()
 }).refine(
   (data) => {
     const ids = (data.banks ?? []).map((bank) => bank.id);
@@ -371,131 +1458,359 @@ var GapSelectDataSchema = z5.looseObject({
 );
 
 // src/schemas/written-response.ts
-import { z as z6 } from "zod/v4";
-var WrittenResponseRubricCriterionSchema = z6.looseObject({
-  name: z6.string().min(1),
-  description: z6.string().optional(),
-  weight: z6.number().min(0)
+import { z as z7 } from "zod/v4";
+var WrittenResponseRubricCriterionSchema = z7.looseObject({
+  name: z7.string().min(1),
+  description: z7.string().optional(),
+  weight: z7.number().min(0)
 });
-var WrittenResponseRubricSchema = z6.looseObject({
-  label: z6.string().optional(),
-  criteria: z6.array(WrittenResponseRubricCriterionSchema).min(1)
+var WrittenResponseRubricSchema = z7.looseObject({
+  label: z7.string().optional(),
+  criteria: z7.array(WrittenResponseRubricCriterionSchema).min(1)
 });
-var RedactedWrittenResponseRubricCriterionSchema = z6.strictObject({
-  name: z6.string().min(1),
-  description: z6.string().optional(),
-  weight: z6.number().min(0)
+var RedactedWrittenResponseRubricCriterionSchema = z7.strictObject({
+  name: z7.string().min(1),
+  description: z7.string().optional(),
+  weight: z7.number().min(0)
 });
-var RedactedWrittenResponseRubricSchema = z6.strictObject({
-  label: z6.string().optional(),
-  criteria: z6.array(RedactedWrittenResponseRubricCriterionSchema).min(1)
+var RedactedWrittenResponseRubricSchema = z7.strictObject({
+  label: z7.string().optional(),
+  criteria: z7.array(RedactedWrittenResponseRubricCriterionSchema).min(1)
 });
-var WrittenResponseDataSchema = z6.looseObject({
-  schemaVersion: z6.literal("1.0"),
-  type: z6.literal("written-response"),
-  id: z6.string().min(1),
-  title: z6.string().min(1),
-  prompt: z6.string(),
-  promptHtml: z6.string().optional(),
-  minWords: z6.number().int().min(0),
-  maxWords: z6.number().int().min(1),
+var WrittenResponseDataSchema = z7.looseObject({
+  schemaVersion: z7.literal("1.0"),
+  type: z7.literal("written-response"),
+  id: z7.string().min(1),
+  title: z7.string().min(1),
+  prompt: z7.string(),
+  promptHtml: z7.string().optional(),
+  minWords: z7.number().int().min(0),
+  maxWords: z7.number().int().min(1),
   rubric: WrittenResponseRubricSchema.optional(),
-  languageTarget: z6.string().optional(),
+  languageTarget: z7.string().optional(),
   media: MediaSchema.optional(),
   feedback: FeedbackSchema.optional(),
-  passThreshold: z6.number().min(0).max(1).optional(),
-  locale: z6.string().optional(),
-  learningObjectives: z6.array(z6.string()).optional(),
-  difficultyLevel: z6.literal([1, 2, 3, 4, 5]).optional()
+  passThreshold: z7.number().min(0).max(1).optional(),
+  locale: z7.string().optional(),
+  learningObjectives: z7.array(z7.string()).optional(),
+  difficultyLevel: z7.literal([1, 2, 3, 4, 5]).optional()
 }).refine((data) => data.maxWords >= data.minWords, {
   error: "maxWords must be greater than or equal to minWords.",
   path: ["maxWords"]
 });
 
 // src/schemas/redacted.ts
-import { z as z7 } from "zod/v4";
+import { z as z8 } from "zod/v4";
 var redactedBase = {
   /** Marker distinguishing a redacted projection from full activity data. */
-  redacted: z7.literal(true),
+  redacted: z8.literal(true),
   /** Slot identity, carried through redaction so the client and the plan agree. */
-  slotKey: z7.string().min(1).optional(),
-  schemaVersion: z7.literal("1.0"),
-  id: z7.string().min(1),
-  title: z7.string().min(1),
+  slotKey: z8.string().min(1).optional(),
+  schemaVersion: z8.literal("1.0"),
+  id: z8.string().min(1),
+  title: z8.string().min(1),
   media: RedactedMediaSchema.optional(),
-  passThreshold: z7.number().min(0).max(1).optional(),
-  locale: z7.string().optional(),
-  learningObjectives: z7.array(z7.string()).optional(),
-  difficultyLevel: z7.literal([1, 2, 3, 4, 5]).optional()
+  passThreshold: z8.number().min(0).max(1).optional(),
+  locale: z8.string().optional(),
+  learningObjectives: z8.array(z8.string()).optional(),
+  difficultyLevel: z8.literal([1, 2, 3, 4, 5]).optional()
 };
-var RedactedMultipleChoiceOptionMediaSchema = z7.strictObject({
-  type: z7.enum(["image", "audio"]),
-  url: z7.string().min(1),
-  alt: z7.string().min(1).optional(),
-  captionsUrl: z7.string().min(1).optional()
+var RedactedMultipleChoiceOptionMediaSchema = z8.strictObject({
+  type: z8.enum(["image", "audio"]),
+  url: z8.string().min(1),
+  alt: z8.string().min(1).optional(),
+  captionsUrl: z8.string().min(1).optional()
 });
-var RedactedMultipleChoiceOptionSchema = z7.strictObject({
-  id: z7.string().min(1),
-  text: z7.string().min(1),
+var RedactedMultipleChoiceOptionSchema = z8.strictObject({
+  id: z8.string().min(1),
+  text: z8.string().min(1),
   media: RedactedMultipleChoiceOptionMediaSchema.optional()
 });
-var RedactedMultipleChoiceDataSchema = z7.strictObject({
+var RedactedMultipleChoiceDataSchema = z8.strictObject({
   ...redactedBase,
-  type: z7.literal("multiple-choice"),
-  question: z7.string().min(1),
-  questionHtml: z7.string().optional(),
-  mode: z7.enum(["single", "multi"]),
-  options: z7.array(RedactedMultipleChoiceOptionSchema).min(2).max(26),
-  shuffle: z7.boolean().optional()
+  type: z8.literal("multiple-choice"),
+  question: z8.string().min(1),
+  questionHtml: z8.string().optional(),
+  mode: z8.enum(["single", "multi"]),
+  options: z8.array(RedactedMultipleChoiceOptionSchema).min(2).max(26),
+  shuffle: z8.boolean().optional()
 });
-var RedactedBlankConfigSchema = z7.strictObject({
-  id: z7.string().min(1),
-  hint: z7.string().optional()
+var RedactedBlankConfigSchema = z8.strictObject({
+  id: z8.string().min(1),
+  hint: z8.string().optional()
 });
-var RedactedFillInTheBlanksDataSchema = z7.strictObject({
+var RedactedFillInTheBlanksDataSchema = z8.strictObject({
   ...redactedBase,
-  type: z7.literal("fill-in-the-blanks"),
-  passage: z7.string().min(1),
-  passageHtml: z7.string().optional(),
-  blanks: z7.array(RedactedBlankConfigSchema).min(1)
+  type: z8.literal("fill-in-the-blanks"),
+  passage: z8.string().min(1),
+  passageHtml: z8.string().optional(),
+  blanks: z8.array(RedactedBlankConfigSchema).min(1)
 });
-var RedactedGapSelectChoiceSchema = z7.strictObject({
-  id: z7.string().min(1),
-  text: z7.string().min(1)
+var RedactedGapSelectChoiceSchema = z8.strictObject({
+  id: z8.string().min(1),
+  text: z8.string().min(1)
 });
-var RedactedGapSelectBankSchema = z7.strictObject({
-  id: z7.string().min(1),
-  choices: z7.array(RedactedGapSelectChoiceSchema).min(2)
+var RedactedGapSelectBankSchema = z8.strictObject({
+  id: z8.string().min(1),
+  choices: z8.array(RedactedGapSelectChoiceSchema).min(2)
 });
-var RedactedGapSelectGapSchema = z7.strictObject({
-  id: z7.string().min(1),
-  choices: z7.array(RedactedGapSelectChoiceSchema).min(2).optional(),
-  bankId: z7.string().min(1).optional()
+var RedactedGapSelectGapSchema = z8.strictObject({
+  id: z8.string().min(1),
+  choices: z8.array(RedactedGapSelectChoiceSchema).min(2).optional(),
+  bankId: z8.string().min(1).optional()
 });
-var RedactedGapSelectDataSchema = z7.strictObject({
+var RedactedGapSelectDataSchema = z8.strictObject({
   ...redactedBase,
-  type: z7.literal("gap-select"),
-  passage: z7.string().min(1),
-  passageHtml: z7.string().optional(),
-  gaps: z7.array(RedactedGapSelectGapSchema).min(1),
-  banks: z7.array(RedactedGapSelectBankSchema).optional(),
-  presentation: z7.literal("dropdown").optional(),
-  shuffleChoices: z7.boolean().optional()
+  type: z8.literal("gap-select"),
+  passage: z8.string().min(1),
+  passageHtml: z8.string().optional(),
+  gaps: z8.array(RedactedGapSelectGapSchema).min(1),
+  banks: z8.array(RedactedGapSelectBankSchema).optional(),
+  presentation: z8.literal("dropdown").optional(),
+  shuffleChoices: z8.boolean().optional()
 });
-var RedactedWrittenResponseDataSchema = z7.strictObject({
+var RedactedWrittenResponseDataSchema = z8.strictObject({
   ...redactedBase,
-  type: z7.literal("written-response"),
-  prompt: z7.string(),
-  promptHtml: z7.string().optional(),
-  minWords: z7.number().int().min(0),
-  maxWords: z7.number().int().min(1),
+  type: z8.literal("written-response"),
+  prompt: z8.string(),
+  promptHtml: z8.string().optional(),
+  minWords: z8.number().int().min(0),
+  maxWords: z8.number().int().min(1),
   rubric: RedactedWrittenResponseRubricSchema.optional(),
-  languageTarget: z7.string().optional()
+  languageTarget: z8.string().optional()
+});
+var RedactedDictationSlowMediaSchema = z8.strictObject({
+  type: z8.literal("audio"),
+  url: MediaUrlSchema,
+  alt: z8.string().min(1).optional()
+});
+var RedactedDictationDataSchema = z8.strictObject({
+  ...redactedBase,
+  type: z8.literal("dictation"),
+  slowMedia: RedactedDictationSlowMediaSchema.optional(),
+  hints: z8.strictObject({ mode: z8.literal("progressive-words") }).optional()
+}).check((ctx) => {
+  const data = ctx.value;
+  if (data.media?.captionsUrl !== void 0) {
+    ctx.issues.push({
+      code: "custom",
+      input: data.media.captionsUrl,
+      message: "A dictation recording cannot carry captions: the captions are the answer, so this payload is not learner-safe.",
+      path: ["media", "captionsUrl"]
+    });
+  }
+  if (data.slowMedia !== void 0 && data.media?.playback?.maxPlays !== void 0) {
+    ctx.issues.push({
+      code: "custom",
+      input: data.slowMedia,
+      message: "A play budget on `media` cannot coexist with an unbudgeted slow recording of the same content.",
+      path: ["slowMedia"]
+    });
+  }
+  if (data.slowMedia !== void 0 && data.media === void 0) {
+    ctx.issues.push({
+      code: "custom",
+      input: data.slowMedia,
+      message: "A slow recording accompanies a recording: this payload has no `media`.",
+      path: ["media"]
+    });
+  }
 });
 
+// src/scoring/dictation/edit-distance.ts
+function codePoints(text) {
+  return Array.from(text, (character) => character.codePointAt(0));
+}
+function editDistance(a, b) {
+  if (a === b) {
+    return 0;
+  }
+  let left = codePoints(a);
+  let right = codePoints(b);
+  if (left.length < right.length) {
+    [left, right] = [right, left];
+  }
+  if (right.length === 0) {
+    return left.length;
+  }
+  let previous = new Uint32Array(right.length + 1);
+  let current = new Uint32Array(right.length + 1);
+  for (let j = 0; j <= right.length; j += 1) {
+    previous[j] = j;
+  }
+  for (let i = 1; i <= left.length; i += 1) {
+    current[0] = i;
+    const leftPoint = left[i - 1];
+    for (let j = 1; j <= right.length; j += 1) {
+      const deletion = previous[j] + 1;
+      const insertion = current[j - 1] + 1;
+      const substitution = previous[j - 1] + (leftPoint === right[j - 1] ? 0 : 1);
+      current[j] = Math.min(deletion, insertion, substitution);
+    }
+    [previous, current] = [current, previous];
+  }
+  return previous[right.length];
+}
+function similarity(a, b) {
+  const max = Math.max(codePoints(a).length, codePoints(b).length);
+  return max === 0 ? 0 : (max - editDistance(a, b)) / max;
+}
+
+// src/scoring/dictation/align.ts
+function dictationReferenceWords(data) {
+  return rawCandidates(data).map(
+    (candidate) => tokensOf(normalizeCandidate(candidate, data)).map((word, index) => ({
+      itemId: `w${index + 1}`,
+      word
+    }))
+  );
+}
+function alignDictation(data, text) {
+  const raw = typeof text === "string" ? text : "";
+  const capped = truncateCodePoints(raw, DICTATION_MAX_TEXT_LENGTH);
+  const { text: normalized, cut } = normalizeDictationTextBounded(capped, data.tolerance);
+  const attempt = cutAt(normalized, DICTATION_MAX_TEXT_LENGTH);
+  const truncated = cut || capped.length < raw.length || attempt.length < normalized.length;
+  const candidates = [];
+  rawCandidates(data).forEach((candidate, index) => {
+    const candidateText = normalizeCandidate(candidate, data);
+    if (candidateText !== "") {
+      candidates.push({ index, text: candidateText });
+    }
+  });
+  if (candidates.length === 0) {
+    return { candidateIndex: -1, reference: "", attempt, truncated, similarity: 0, words: [] };
+  }
+  let chosen = candidates[0];
+  let best = similarity(chosen.text, attempt);
+  for (const candidate of candidates.slice(1)) {
+    const candidateSimilarity = similarity(candidate.text, attempt);
+    if (candidateSimilarity > best) {
+      best = candidateSimilarity;
+      chosen = candidate;
+    }
+  }
+  return {
+    candidateIndex: chosen.index,
+    reference: chosen.text,
+    attempt,
+    truncated,
+    similarity: best,
+    words: alignWords(tokensOf(chosen.text), tokensOf(attempt))
+  };
+}
+function rawCandidates(data) {
+  return [
+    data.transcript,
+    ...Array.isArray(data.acceptedTranscripts) ? data.acceptedTranscripts.slice(0, DICTATION_MAX_ACCEPTED_TRANSCRIPTS) : []
+  ];
+}
+function normalizeCandidate(candidate, data) {
+  return typeof candidate === "string" ? cutAt(
+    normalizeDictationText(
+      truncateCodePoints(candidate, DICTATION_MAX_TRANSCRIPT_LENGTH),
+      data.tolerance
+    ),
+    DICTATION_MAX_TRANSCRIPT_LENGTH
+  ) : "";
+}
+function cutAt(normalized, max) {
+  const cut = truncateCodePoints(normalized, max);
+  return cut.endsWith(" ") ? cut.slice(0, -1) : cut;
+}
+function tokensOf(normalized) {
+  return normalized === "" ? [] : normalized.split(" ");
+}
+var STEP = {
+  /** A reference element paired with an attempt element — equal or substituted. */
+  pair: 0,
+  /** A reference element the attempt lacks. */
+  missing: 1,
+  /** An attempt element the reference lacks. */
+  extra: 2
+};
+function alignSequences(reference, attempt) {
+  const rows = reference.length;
+  const columns = attempt.length;
+  const width = columns + 1;
+  const steps = new Uint8Array((rows + 1) * width);
+  let previous = new Uint32Array(width);
+  let current = new Uint32Array(width);
+  for (let j2 = 0; j2 <= columns; j2 += 1) {
+    previous[j2] = j2;
+    steps[j2] = STEP.extra;
+  }
+  for (let i2 = 1; i2 <= rows; i2 += 1) {
+    current[0] = i2;
+    steps[i2 * width] = STEP.missing;
+    const referenceItem = reference[i2 - 1];
+    for (let j2 = 1; j2 <= columns; j2 += 1) {
+      const paired = previous[j2 - 1] + (referenceItem === attempt[j2 - 1] ? 0 : 1);
+      const missing = previous[j2] + 1;
+      const extra = current[j2 - 1] + 1;
+      const cost = Math.min(paired, missing, extra);
+      current[j2] = cost;
+      steps[i2 * width + j2] = paired === cost ? STEP.pair : missing === cost ? STEP.missing : STEP.extra;
+    }
+    [previous, current] = [current, previous];
+  }
+  const path = [];
+  let i = rows;
+  let j = columns;
+  while (i > 0 || j > 0) {
+    const step = steps[i * width + j];
+    if (step === STEP.pair) {
+      i -= 1;
+      j -= 1;
+    } else if (step === STEP.missing) {
+      i -= 1;
+    } else {
+      j -= 1;
+    }
+    path.push({ step, referenceIndex: i, attemptIndex: j });
+  }
+  return path.reverse();
+}
+function alignWords(reference, attempt) {
+  const words = [];
+  let ordinal = 0;
+  for (const { step, referenceIndex, attemptIndex } of alignSequences(reference, attempt)) {
+    if (step === STEP.extra) {
+      words.push({
+        reference: "",
+        attempt: attempt[attemptIndex],
+        similarity: 0,
+        status: "extra"
+      });
+      continue;
+    }
+    ordinal += 1;
+    const referenceWord = reference[referenceIndex];
+    if (step === STEP.missing) {
+      words.push({
+        itemId: `w${ordinal}`,
+        reference: referenceWord,
+        attempt: "",
+        similarity: 0,
+        status: "missing"
+      });
+      continue;
+    }
+    const attemptWord = attempt[attemptIndex];
+    words.push({
+      itemId: `w${ordinal}`,
+      reference: referenceWord,
+      attempt: attemptWord,
+      similarity: similarity(referenceWord, attemptWord),
+      status: referenceWord === attemptWord ? "correct" : "incorrect"
+    });
+  }
+  return words;
+}
+
 // src/scoring/text-match.ts
 var COMBINING_MARKS_RE = /\p{M}/gu;
-var PUNCTUATION_RE = /\p{P}/gu;
+var PUNCTUATION_RE2 = /\p{P}/gu;
 function applyBaseline(value, policy) {
   let result = value;
   if (policy.trim !== false) {
@@ -512,7 +1827,7 @@ function applyNormalization(value, policy) {
     result = result.normalize(policy.normalize);
   }
   if (policy.ignorePunctuation === true) {
-    result = result.replace(PUNCTUATION_RE, "");
+    result = result.replace(PUNCTUATION_RE2, "");
   }
   if (policy.collapseInnerWhitespace === true) {
     result = result.replace(/(?<=\S)\s+(?=\S)/g, " ");
@@ -700,7 +2015,29 @@ var DRAFT_ISSUE_SEVERITY = {
   wr_criterion_weight_required: "incomplete",
   wr_criterion_weight_invalid: "invalid",
   wr_rubric_weights_zero: "incomplete",
-  wr_rubric_weights_too_large: "invalid"
+  wr_rubric_weights_too_large: "invalid",
+  // dictation
+  dc_transcript_required: "incomplete",
+  dc_transcript_unscorable: "invalid",
+  dc_transcript_too_long: "invalid",
+  dc_accepted_transcript_empty: "incomplete",
+  dc_accepted_transcript_too_long: "invalid",
+  dc_accepted_transcript_duplicate: "invalid",
+  dc_accepted_transcripts_too_many: "invalid",
+  dc_media_kind: "invalid",
+  dc_captions_not_allowed: "invalid",
+  dc_slow_media_kind: "invalid",
+  dc_slow_media_playback: "invalid",
+  dc_slow_media_unbudgeted: "invalid",
+  dc_slow_media_same_url: "invalid",
+  dc_slow_media_without_media: "incomplete",
+  dc_transcript_revealed: "invalid",
+  dc_shown_text_too_long: "invalid",
+  dc_hints_mode_required: "incomplete",
+  dc_hints_mode_invalid: "invalid",
+  dc_equivalence_from_required: "incomplete",
+  dc_equivalence_to_required: "incomplete",
+  dc_tolerance_invalid: "invalid"
 };
 function issue(code, path, message) {
   return { path: path.map(String), message, code, severity: DRAFT_ISSUE_SEVERITY[code] };
@@ -879,6 +2216,355 @@ function covers(reported, failed) {
   }
   return failed.every((segment, index) => reported[index] === segment);
 }
+function pathKey(path) {
+  return path.length === 0 ? "" : JSON.stringify(path.map(String));
+}
+function coveredPathsOf(reported) {
+  const covered = /* @__PURE__ */ new Set();
+  for (const known of reported) {
+    if (known.path.length === 0) {
+      covered.add("");
+    }
+    for (let length = 1; length <= known.path.length; length += 1) {
+      covered.add(pathKey(known.path.slice(0, length)));
+    }
+  }
+  return covered;
+}
+
+// src/authoring/dictation.ts
+var dictationAuthoring = {
+  createDraft: ({ newId }) => ({
+    schemaVersion: "1.0",
+    type: "dictation",
+    id: newId(),
+    title: "",
+    transcript: ""
+  }),
+  checkDraft: checkDictationDraft
+};
+function checkDictationDraft(draft) {
+  const issues = checkIdentity(draft, "dictation");
+  const tolerance = isRecord(draft.tolerance) ? draft.tolerance : void 0;
+  const normalizer = dictationNormalizer(tolerance);
+  issues.push(...checkTranscript(draft.transcript, normalizer));
+  issues.push(...checkAcceptedTranscripts(draft, normalizer));
+  issues.push(...checkRecording(draft.media));
+  issues.push(...checkSlowRecording(draft));
+  issues.push(...checkRevealed(draft, normalizer));
+  issues.push(...checkHints(draft.hints));
+  issues.push(...checkTolerance(draft.tolerance));
+  issues.push(...checkSharedOptional(draft));
+  return issues;
+}
+function isUnwrittenTranscript(value) {
+  if (typeof value === "string" && isLongerThan(value, DICTATION_MAX_TRANSCRIPT_LENGTH)) {
+    return false;
+  }
+  return isUnwritten(value) || typeof value === "string" && isBlankBeforeRules(value);
+}
+function acceptedTranscriptsRead(accepted) {
+  return accepted.slice(0, DICTATION_MAX_ACCEPTED_TRANSCRIPTS);
+}
+function checkTranscript(transcript, normalizer) {
+  if (isUnwrittenTranscript(transcript)) {
+    return [issue("dc_transcript_required", ["transcript"], "Write the transcript.")];
+  }
+  if (typeof transcript !== "string") {
+    return [];
+  }
+  const measured = normalizer.measure(transcript);
+  if (measured.tooLong) {
+    return [
+      issue(
+        "dc_transcript_too_long",
+        ["transcript"],
+        `The transcript is longer than ${DICTATION_MAX_TRANSCRIPT_LENGTH} characters before or after its equivalences are applied, or they grow it past ${WORKING_LENGTH} characters on the way. A dictation is a sentence or two.`
+      )
+    ];
+  }
+  if (measured.normalized === "") {
+    return [
+      issue(
+        "dc_transcript_unscorable",
+        ["transcript"],
+        "The transcript has nothing to type: once case, punctuation and spacing are ignored, nothing is left."
+      )
+    ];
+  }
+  return [];
+}
+function checkAcceptedTranscripts(draft, normalizer) {
+  const accepted = draft.acceptedTranscripts;
+  if (!Array.isArray(accepted)) {
+    return [];
+  }
+  const issues = [];
+  if (accepted.length > DICTATION_MAX_ACCEPTED_TRANSCRIPTS) {
+    issues.push(
+      issue(
+        "dc_accepted_transcripts_too_many",
+        ["acceptedTranscripts"],
+        `At most ${DICTATION_MAX_ACCEPTED_TRANSCRIPTS} accepted transcripts. Prefer an equivalence for a word that varies.`
+      )
+    );
+  }
+  for (const [index, text] of accepted.entries()) {
+    if (typeof text !== "string") {
+      continue;
+    }
+    if (index >= DICTATION_MAX_ACCEPTED_TRANSCRIPTS) {
+      if (text === "") {
+        issues.push(acceptedTranscriptEmpty(index));
+      }
+      continue;
+    }
+    const measured = normalizer.measure(text);
+    if (measured.tooLong) {
+      issues.push(
+        issue(
+          "dc_accepted_transcript_too_long",
+          ["acceptedTranscripts", index],
+          `Accepted transcript ${index + 1} is longer than ${DICTATION_MAX_TRANSCRIPT_LENGTH} characters before or after its equivalences are applied, or they grow it past ${WORKING_LENGTH} characters on the way.`
+        )
+      );
+    } else if (measured.normalized === "") {
+      issues.push(acceptedTranscriptEmpty(index));
+    }
+  }
+  const candidates = [draft.transcript, ...acceptedTranscriptsRead(accepted)].filter((text) => typeof text === "string").map((text) => normalizer.measure(text).normalized).filter((text) => text !== null && text !== "");
+  if (new Set(candidates).size !== candidates.length) {
+    issues.push(
+      issue(
+        "dc_accepted_transcript_duplicate",
+        ["acceptedTranscripts"],
+        "An accepted transcript repeats the transcript, or another accepted transcript, once case, punctuation and spacing are ignored. Remove it."
+      )
+    );
+  }
+  return issues;
+}
+function acceptedTranscriptEmpty(index) {
+  return issue(
+    "dc_accepted_transcript_empty",
+    ["acceptedTranscripts", index],
+    `Accepted transcript ${index + 1} has nothing to type. Fill it in or remove it.`
+  );
+}
+function checkRecording(media) {
+  if (!isRecord(media)) {
+    return [];
+  }
+  const issues = [];
+  const kind = media.type;
+  if (!isUnwritten(kind) && kind !== "audio") {
+    issues.push(
+      issue(
+        "dc_media_kind",
+        ["media", "type"],
+        "A dictation is dictated: its recording must be audio."
+      )
+    );
+  }
+  if (!isUnset(media.captionsUrl)) {
+    issues.push(
+      issue("dc_captions_not_allowed", ["media", "captionsUrl"], CAPTIONS_ARE_THE_ANSWER)
+    );
+  }
+  return issues;
+}
+var CAPTIONS_ARE_THE_ANSWER = "A dictation recording cannot carry captions: the captions are the answer. Remove them, and offer an accessible alternative as a different item.";
+function checkSlowRecording(draft) {
+  const slow = draft.slowMedia;
+  if (!isRecord(slow)) {
+    return [];
+  }
+  const issues = [];
+  const kind = slow.type;
+  const wrongKind = !isUnwritten(kind) && kind !== "audio";
+  if (wrongKind) {
+    issues.push(
+      issue("dc_slow_media_kind", ["slowMedia", "type"], "The slow recording must be audio.")
+    );
+  }
+  issues.push(
+    ...checkMedia(
+      wrongKind ? { ...slow, type: "audio" } : slow,
+      ["slowMedia"],
+      DictationSlowMediaSchema
+    )
+  );
+  if (!isUnset(slow.captionsUrl)) {
+    issues.push(
+      issue("dc_captions_not_allowed", ["slowMedia", "captionsUrl"], CAPTIONS_ARE_THE_ANSWER)
+    );
+  }
+  if (slow.playback !== void 0) {
+    issues.push(
+      issue(
+        "dc_slow_media_playback",
+        ["slowMedia", "playback"],
+        "The slow recording has no playback policy of its own. Put the policy on the recording; the slow recording follows it, except the play budget."
+      )
+    );
+  }
+  const media = draft.media;
+  if (isUnset(media)) {
+    issues.push(
+      issue(
+        "dc_slow_media_without_media",
+        ["media"],
+        "A slow recording accompanies a recording. Add the recording first."
+      )
+    );
+    return issues;
+  }
+  if (!isRecord(media)) {
+    return issues;
+  }
+  if (isRecord(media.playback) && media.playback.maxPlays !== void 0) {
+    issues.push(
+      issue(
+        "dc_slow_media_unbudgeted",
+        ["slowMedia"],
+        "A play budget on the recording cannot coexist with a slow recording that has none. Remove the slow recording, or remove the play limit."
+      )
+    );
+  }
+  if (typeof slow.url === "string" && slow.url !== "" && slow.url === media.url) {
+    issues.push(
+      issue(
+        "dc_slow_media_same_url",
+        ["slowMedia", "url"],
+        "The slow recording is the same file as the recording. Point it at the slower render."
+      )
+    );
+  }
+  return issues;
+}
+function checkRevealed(draft, normalizer) {
+  const candidates = [
+    draft.transcript,
+    ...Array.isArray(draft.acceptedTranscripts) ? acceptedTranscriptsRead(draft.acceptedTranscripts) : []
+  ].filter((text) => typeof text === "string").map((text) => normalizer.measure(text));
+  const shown = [
+    [["title"], draft.title],
+    [["media", "alt"], isRecord(draft.media) ? draft.media.alt : void 0],
+    [["slowMedia", "alt"], isRecord(draft.slowMedia) ? draft.slowMedia.alt : void 0]
+  ];
+  const issues = [];
+  for (const [path, text] of shown) {
+    if (typeof text !== "string") {
+      continue;
+    }
+    const { tooLong, forms } = normalizer.shown(text);
+    if (tooLong) {
+      issues.push(
+        issue(
+          "dc_shown_text_too_long",
+          path,
+          `${path[0] === "title" ? "The title" : "The description"} is too long to be checked for the transcript: at most ${WORKING_LENGTH} characters before and after the equivalences are applied, and they may not grow it past that on the way.`
+        )
+      );
+    } else if (candidates.some((candidate) => revealsCandidate(forms, candidate))) {
+      issues.push(
+        issue(
+          "dc_transcript_revealed",
+          path,
+          path[0] === "title" ? 'The title gives the answer away: it contains the transcript. Name the exercise instead ("Listen and type the sentence").' : 'The description gives the answer away: it contains the transcript. Describe the recording ("Recording, normal speed"), never transcribe it.'
+        )
+      );
+    }
+  }
+  return issues;
+}
+function checkHints(hints) {
+  if (!isRecord(hints)) {
+    return [];
+  }
+  const mode = hints.mode;
+  if (isUnwritten(mode)) {
+    return [issue("dc_hints_mode_required", ["hints", "mode"], "Choose how hints are given.")];
+  }
+  if (mode !== "progressive-words") {
+    return [
+      issue(
+        "dc_hints_mode_invalid",
+        ["hints", "mode"],
+        'The only hint mode is "progressive-words". Leave hints out unless you mean to offer them.'
+      )
+    ];
+  }
+  return [];
+}
+function checkTolerance(tolerance) {
+  if (isUnset(tolerance)) {
+    return [];
+  }
+  if (!isRecord(tolerance)) {
+    return [
+      issue(
+        "dc_tolerance_invalid",
+        ["tolerance"],
+        "The tolerances are an object: `{ equivalences: [{ from, to }] }`."
+      )
+    ];
+  }
+  const issues = [];
+  const rules = tolerance.equivalences;
+  if (Array.isArray(rules)) {
+    if (rules.length > DICTATION_MAX_EQUIVALENCES) {
+      issues.push(
+        issue(
+          "dc_tolerance_invalid",
+          ["tolerance", "equivalences"],
+          `A dictation carries at most ${DICTATION_MAX_EQUIVALENCES} equivalence rules.`
+        )
+      );
+    }
+    for (const [index, rule] of rules.entries()) {
+      if (!isRecord(rule)) {
+        continue;
+      }
+      const path = ["tolerance", "equivalences", index];
+      const from = rule.from;
+      if (isUnwritten(from) || typeof from === "string" && preStripNormalize(from) === "") {
+        issues.push(
+          issue(
+            "dc_equivalence_from_required",
+            [...path, "from"],
+            `Say what rule ${index + 1} rewrites: a word, a phrase or a symbol.`
+          )
+        );
+      }
+      const to = rule.to;
+      if (isUnwritten(to) || typeof to === "string" && normalizeDictationText(to) === "") {
+        issues.push(
+          issue(
+            "dc_equivalence_to_required",
+            [...path, "to"],
+            `Say what rule ${index + 1} rewrites to. A rule cannot delete a word or leave only punctuation.`
+          )
+        );
+      }
+    }
+  }
+  const parsed = DictationToleranceSchema.safeParse(tolerance, { reportInput: true });
+  if (!parsed.success) {
+    const covered = coveredPathsOf(issues);
+    for (const schemaIssue of parsed.error.issues) {
+      const path = ["tolerance", ...schemaIssue.path.map(String)];
+      if (refusesEmpty(tolerance, schemaIssue) || covered.has(pathKey(path))) {
+        continue;
+      }
+      issues.push(issue("dc_tolerance_invalid", path, schemaIssue.message));
+      for (const key of coveredPathsOf([{ path }])) {
+        covered.add(key);
+      }
+    }
+  }
+  return issues;
+}
 
 // src/authoring/fill-in-the-blanks.ts
 var fillInTheBlanksAuthoring = {
@@ -1633,6 +3319,27 @@ function checkCriteria(criteria) {
   return issues;
 }
 
+// src/scoring/activity-scorers/dictation.ts
+function scoreDictation(data, response) {
+  const alignment = alignDictation(data, typeof response?.text === "string" ? response.text : "");
+  const details = [];
+  for (const word of alignment.words) {
+    if (word.status === "extra") {
+      continue;
+    }
+    details.push({
+      itemId: word.itemId,
+      correct: word.status === "correct",
+      outcome: word.status === "correct" ? "correct" : word.status === "incorrect" ? "incorrect" : "incorrect-omission",
+      learnerResponse: word.attempt,
+      correctResponse: word.reference,
+      score: word.similarity,
+      weight: 1
+    });
+  }
+  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;
@@ -1860,6 +3567,15 @@ var FILL_IN_THE_BLANKS_FIELD_POLICY = {
     feedback: "answer-key"
   }
 };
+var DICTATION_FIELD_POLICY = {
+  ...SHARED_PUBLIC_FIELDS,
+  transcript: "answer-key",
+  acceptedTranscripts: "answer-key",
+  slowMedia: { type: "public", url: "public", alt: "public" },
+  hints: { mode: "public" },
+  tolerance: "answer-key",
+  feedback: FEEDBACK_FIELD_POLICY
+};
 var RUBRIC_FIELD_POLICY = {
   label: "public",
   // Applies to every element of the array.
@@ -1973,25 +3689,63 @@ var gapSelectType = defineActivityType({
   interactions: ["gap-selected", "submitted"],
   authoring: gapSelectAuthoring
 });
+var dictationType = defineActivityType({
+  type: "dictation",
+  schema: DictationDataSchema,
+  scoring: { kind: "sync", score: scoreDictation },
+  // Whitespace-only or punctuation-only text is no answer. Without the
+  // tolerance, which this signature cannot see: the one gap is an attempt made
+  // ONLY of a symbol an equivalence names, which reads as unanswered here and
+  // is scored as the rewritten word — documented in the authoring guide. The
+  // reverse cannot happen: a rule inserts words, never nothing, and the text is
+  // cut where the scorer cuts, so text past the cap never counts as an answer.
+  isAnswered: (response) => normalizeDictationText(
+    truncateCodePoints(
+      typeof response?.text === "string" ? response.text : "",
+      DICTATION_MAX_TEXT_LENGTH
+    )
+  ) !== "",
+  fieldPolicy: DICTATION_FIELD_POLICY,
+  redactedSchema: RedactedDictationDataSchema,
+  interop: {
+    xapiActivityTypeIri: "http://adlnet.gov/expapi/activities/cmi.interaction",
+    // `fill-in`, as for fill-in-the-blanks: a typed answer with a key pattern.
+    // `long-fill-in` is what written-response uses for free text nothing scores.
+    xapiInteractionType: "fill-in",
+    correctResponsesPattern: (data) => [data.transcript, ...data.acceptedTranscripts ?? []]
+  },
+  interactions: ["text-changed", "hint-requested", "submitted"],
+  authoring: dictationAuthoring
+});
 registerActivityType(multipleChoiceType);
 registerActivityType(fillInTheBlanksType);
 registerActivityType(writtenResponseType);
 registerActivityType(gapSelectType);
+registerActivityType(dictationType);
 
 export {
   ActivitySchemaError,
   UnknownActivityTypeError,
   RedactedScoringError,
   DeferredScoringError,
+  withValidationScope,
+  DICTATION_MAX_TRANSCRIPT_LENGTH,
+  DICTATION_MAX_TEXT_LENGTH,
+  DICTATION_MAX_EQUIVALENCE_LENGTH,
+  DICTATION_MAX_EQUIVALENCES,
+  DICTATION_MAX_ACCEPTED_TRANSCRIPTS,
   FeedbackSchema,
   MediaUrlSchema,
   NativeControlHintSchema,
   MediaPlaybackSchema,
   MediaSchema,
   RedactedMediaSchema,
-  TextMatchPolicySchema,
-  BlankConfigSchema,
-  FillInTheBlanksDataSchema,
+  DictationSlowMediaSchema,
+  DictationEquivalenceSchema,
+  DictationToleranceSchema,
+  DictationDataSchema,
+  groupCaptionsRevealDictation,
+  GROUP_CAPTIONS_REVEAL_DICTATION,
   DRAFT_ISSUE_SEVERITY,
   issue,
   isRecord,
@@ -2001,6 +3755,11 @@ export {
   isMissingId,
   checkMedia,
   covers,
+  pathKey,
+  coveredPathsOf,
+  TextMatchPolicySchema,
+  BlankConfigSchema,
+  FillInTheBlanksDataSchema,
   MultipleChoiceOptionMediaSchema,
   MultipleChoiceOptionSchema,
   MultipleChoiceDataSchema,
@@ -2022,6 +3781,12 @@ export {
   RedactedGapSelectGapSchema,
   RedactedGapSelectDataSchema,
   RedactedWrittenResponseDataSchema,
+  RedactedDictationSlowMediaSchema,
+  RedactedDictationDataSchema,
+  dictationReferenceWords,
+  alignDictation,
+  STEP,
+  alignSequences,
   levenshteinDistance,
   matchText,
   defineActivityType,
@@ -2031,6 +3796,8 @@ export {
   MEDIA_FIELD_POLICY,
   multipleChoiceType,
   fillInTheBlanksType,
-  writtenResponseType
+  writtenResponseType,
+  gapSelectType,
+  dictationType
 };
-//# sourceMappingURL=chunk-FVN37GIH.js.map
+//# sourceMappingURL=chunk-XKKKWKRH.js.map