@intellectif/lk-core 0.12.0 → 0.13.1

package/dist/{chunk-J6POE4HL.cjs → chunk-XONKWL6D.cjs}

@@ -38,6 +38,876 @@ var DeferredScoringError = class extends Error {
   
 };
 
+// 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 = _optionalChain([previous, 'optionalAccess', _2 => _2.codePointAt, 'call', _3 => _3(0)]);
+  if (point === MONGOLIAN_VOWEL_SEPARATOR) {
+    return (isMongolianLetterOrMark(previousPoint) || isMongolianSelector(previousPoint)) && isMongolianLetterOrMark(_optionalChain([points, 'access', _4 => _4[index + 1], 'optionalAccess', _5 => _5.codePointAt, 'call', _6 => _6(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 _nullishCoalesce(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 = _optionalChain([tolerance, 'optionalAccess', _7 => _7.equivalences]);
+  if (!Array.isArray(equivalences)) {
+    return { rules: [], signature: "[]" };
+  }
+  const rules = [];
+  for (const rule of equivalences.slice(0, DICTATION_MAX_EQUIVALENCES)) {
+    const rawFrom = _optionalChain([rule, 'optionalAccess', _8 => _8.from]);
+    const rawTo = _optionalChain([rule, 'optionalAccess', _9 => _9.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 = _optionalChain([memo, 'optionalAccess', _10 => _10.get, 'call', _11 => _11(text)]);
+  if (result === void 0) {
+    result = bounded(preStripNormalize(text));
+    _optionalChain([memo, 'optionalAccess', _12 => _12.set, 'call', _13 => _13(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 = _optionalChain([memo, 'optionalAccess', _14 => _14.get, 'call', _15 => _15(compiled.signature)]);
+  const remembered = _optionalChain([known, 'optionalAccess', _16 => _16.get, 'call', _17 => _17(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 = (_nullishCoalesce(_optionalChain([source, 'access', _18 => _18.match, 'call', _19 => _19(UNSPACED_LETTERS_RE), 'optionalAccess', _20 => _20.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 = _optionalChain([memo, 'optionalAccess', _21 => _21.get, 'call', _22 => _22(forms), 'optionalAccess', _23 => _23.get, 'call', _24 => _24(candidate)]);
+  if (known !== void 0) {
+    return known;
+  }
+  const answer = searchReveal(forms, candidate);
+  if (memo !== void 0) {
+    const byCandidate = _nullishCoalesce(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 = _nullishCoalesce(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
 var _v4 = require('zod/v4');
 var FeedbackSchema = _v4.z.looseObject({
@@ -98,22 +968,22 @@ var MediaSchema = _v4.z.looseObject({
   error: "playback policy is supported on audio media only. An embed is a provider iframe the SDK cannot control at all (it has no reliable JS API for a third-party player); an image has nothing to play; video is deliberately deferred, because a video transport must also own fullscreen and Picture-in-Picture and the SDK will not pretend to govern those yet.",
   path: ["playback"]
 }).refine(
-  (m) => _optionalChain([m, 'access', _2 => _2.playback, 'optionalAccess', _3 => _3.controls]) !== "native" || m.playback.maxPlays === void 0 && m.playback.seek !== "none" && m.playback.rate !== "fixed",
+  (m) => _optionalChain([m, 'access', _25 => _25.playback, 'optionalAccess', _26 => _26.controls]) !== "native" || m.playback.maxPlays === void 0 && m.playback.seek !== "none" && m.playback.rate !== "fixed",
   {
     error: 'controls: "native" cannot carry maxPlays, seek: "none" or rate: "fixed". The browser\'s own bar keeps its play button enabled after a budget is spent, and keeps a scrubber that would move and then silently snap back \u2014 a control that looks operable and does nothing (WCAG 3.2.2 / 4.1.3). Omit `controls` and the SDK transport is used automatically, or use nativeControlHints for a cosmetic hint.',
     path: ["playback", "controls"]
   }
-).refine((m) => _optionalChain([m, 'access', _4 => _4.playback, 'optionalAccess', _5 => _5.maxPlays]) === void 0 || m.playback.seek !== "allow", {
+).refine((m) => _optionalChain([m, 'access', _27 => _27.playback, 'optionalAccess', _28 => _28.maxPlays]) === void 0 || m.playback.seek !== "allow", {
   error: 'maxPlays cannot be combined with seek: "allow". A play is consumed when playback starts from somewhere other than where it stopped, so scrubbing back mid-play would replay the whole recording without spending anything. Omit `seek` \u2014 it resolves to "none" under a budget.',
   path: ["playback", "seek"]
 }).refine(
-  (m) => _optionalChain([m, 'access', _6 => _6.playback, 'optionalAccess', _7 => _7.controls]) !== "minimal" || m.playback.maxPlays !== void 0 || m.playback.seek === "none" || m.playback.rate === "fixed",
+  (m) => _optionalChain([m, 'access', _29 => _29.playback, 'optionalAccess', _30 => _30.controls]) !== "minimal" || m.playback.maxPlays !== void 0 || m.playback.seek === "none" || m.playback.rate === "fixed",
   {
     error: 'controls: "minimal" with nothing to enforce trades the browser\'s localized, familiar control bar for the SDK\'s, and buys nothing. Set maxPlays, seek: "none" or rate: "fixed", or omit `controls`.',
     path: ["playback", "controls"]
   }
 ).refine(
-  (m) => _optionalChain([m, 'access', _8 => _8.playback, 'optionalAccess', _9 => _9.nativeControlHints]) === void 0 || m.playback.controls !== "minimal" && m.playback.maxPlays === void 0 && m.playback.seek !== "none" && m.playback.rate !== "fixed",
+  (m) => _optionalChain([m, 'access', _31 => _31.playback, 'optionalAccess', _32 => _32.nativeControlHints]) === void 0 || m.playback.controls !== "minimal" && m.playback.maxPlays === void 0 && m.playback.seek !== "none" && m.playback.rate !== "fixed",
   {
     error: "nativeControlHints only affects the browser's own control bar, and an enforcing policy replaces that bar with the SDK transport \u2014 so the hints would be silently inert. Use them on an otherwise unrestricted recording, or drop them.",
     path: ["playback", "nativeControlHints"]
@@ -136,6 +1006,223 @@ var RedactedMediaSchema = _v4.z.strictObject({
   path: ["url"]
 });
 
+// src/schemas/dictation.ts
+
+var DictationSlowMediaSchema = _v4.z.looseObject({
+  type: _v4.z.literal("audio"),
+  url: MediaUrlSchema,
+  alt: _v4.z.string().min(1).optional()
+});
+var RuleTextSchema = _v4.z.string().min(1).meta({ maxLength: DICTATION_MAX_EQUIVALENCE_LENGTH });
+var TranscriptTextSchema = _v4.z.string().min(1).meta({ maxLength: DICTATION_MAX_TRANSCRIPT_LENGTH });
+var DictationEquivalenceSchema = _v4.z.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 = _v4.z.looseObject({
+  equivalences: _v4.z.array(DictationEquivalenceSchema).max(DICTATION_MAX_EQUIVALENCES, {
+    error: `A dictation carries at most ${DICTATION_MAX_EQUIVALENCES} equivalence rules.`
+  }).optional()
+});
+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, ..._nullishCoalesce(data.acceptedTranscripts, () => ( []))];
+}
+function isEmpty(measured) {
+  return measured.normalized === "";
+}
+function checkEvenAfterIssues(check) {
+  const guard = new _v4.z.core.$ZodCheck({ check: "custom", when: () => true });
+  guard._zod.check = check;
+  return guard;
+}
+var DictationDataShape = _v4.z.looseObject({
+  schemaVersion: _v4.z.literal("1.0"),
+  type: _v4.z.literal("dictation"),
+  id: _v4.z.string().min(1),
+  title: _v4.z.string().min(1),
+  transcript: TranscriptTextSchema,
+  acceptedTranscripts: _v4.z.array(TranscriptTextSchema).max(DICTATION_MAX_ACCEPTED_TRANSCRIPTS).optional(),
+  media: MediaSchema.optional(),
+  slowMedia: DictationSlowMediaSchema.optional(),
+  hints: _v4.z.looseObject({ mode: _v4.z.literal("progressive-words") }).optional(),
+  tolerance: DictationToleranceSchema.optional(),
+  feedback: FeedbackSchema.optional(),
+  passThreshold: _v4.z.number().min(0).max(1).optional(),
+  locale: _v4.z.string().optional(),
+  learningObjectives: _v4.z.array(_v4.z.string()).optional(),
+  difficultyLevel: _v4.z.literal([1, 2, 3, 4, 5]).optional()
+});
+var DictationDataSchema = DictationDataShape.check(
+  checkEvenAfterIssues((ctx) => {
+    if (ctx.issues.some((issue2) => (_nullishCoalesce(_optionalChain([issue2, 'access', _33 => _33.path, 'optionalAccess', _34 => _34.length]), () => ( 0))) === 0)) {
+      return;
+    }
+    const data = ctx.value;
+    const refused = new Set(ctx.issues.map((issue2) => String(_optionalChain([issue2, 'access', _35 => _35.path, 'optionalAccess', _36 => _36[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 = _nullishCoalesce(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 && _optionalChain([data, 'access', _37 => _37.slowMedia, 'optionalAccess', _38 => _38.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 (_optionalChain([data, 'access', _39 => _39.media, 'optionalAccess', _40 => _40.playback, 'optionalAccess', _41 => _41.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 _optionalChain([data, 'access', _42 => _42.media, 'optionalAccess', _43 => _43.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 && !(_nullishCoalesce(_optionalChain([data, 'access', _44 => _44.tolerance, 'optionalAccess', _45 => _45.equivalences]), () => ( []))).every(
+      (rule) => preStripNormalize(rule.from) !== "" && normalizeDictationText(rule.to) !== ""
+    )) {
+      report(
+        ["tolerance", "equivalences"],
+        _optionalChain([data, 'access', _46 => _46.tolerance, 'optionalAccess', _47 => _47.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 (_optionalChain([recording, 'optionalAccess', _48 => _48.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"], _optionalChain([data, 'access', _49 => _49.media, 'optionalAccess', _50 => _50.alt])],
+      [["slowMedia", "alt"], _optionalChain([data, 'access', _51 => _51.slowMedia, 'optionalAccess', _52 => _52.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
 
 var PLACEHOLDER_RE = /\{\{\s*([^{}]+?)\s*\}\}/g;
@@ -290,7 +1377,7 @@ function resolveChoices(gap, banks) {
   if (gap.bankId === void 0) {
     return void 0;
   }
-  return _optionalChain([banks, 'access', _10 => _10.find, 'call', _11 => _11((bank) => bank.id === gap.bankId), 'optionalAccess', _12 => _12.choices]);
+  return _optionalChain([banks, 'access', _53 => _53.find, 'call', _54 => _54((bank) => bank.id === gap.bankId), 'optionalAccess', _55 => _55.choices]);
 }
 function placeholderCounts(passage) {
   const counts = /* @__PURE__ */ new Map();
@@ -492,10 +1579,238 @@ var RedactedWrittenResponseDataSchema = _v4.z.strictObject({
   rubric: RedactedWrittenResponseRubricSchema.optional(),
   languageTarget: _v4.z.string().optional()
 });
+var RedactedDictationSlowMediaSchema = _v4.z.strictObject({
+  type: _v4.z.literal("audio"),
+  url: MediaUrlSchema,
+  alt: _v4.z.string().min(1).optional()
+});
+var RedactedDictationDataSchema = _v4.z.strictObject({
+  ...redactedBase,
+  type: _v4.z.literal("dictation"),
+  slowMedia: RedactedDictationSlowMediaSchema.optional(),
+  hints: _v4.z.strictObject({ mode: _v4.z.literal("progressive-words") }).optional()
+}).check((ctx) => {
+  const data = ctx.value;
+  if (_optionalChain([data, 'access', _56 => _56.media, 'optionalAccess', _57 => _57.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 && _optionalChain([data, 'access', _58 => _58.media, 'optionalAccess', _59 => _59.playback, 'optionalAccess', _60 => _60.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 _optionalChain([response, 'optionalAccess', _61 => _61.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;
@@ -1683,7 +3390,7 @@ function choicesFor(data, gap) {
   if (gap.choices !== void 0) {
     return gap.choices;
   }
-  return _nullishCoalesce(_optionalChain([data, 'access', _13 => _13.banks, 'optionalAccess', _14 => _14.find, 'call', _15 => _15((bank) => bank.id === gap.bankId), 'optionalAccess', _16 => _16.choices]), () => ( []));
+  return _nullishCoalesce(_optionalChain([data, 'access', _62 => _62.banks, 'optionalAccess', _63 => _63.find, 'call', _64 => _64((bank) => bank.id === gap.bankId), 'optionalAccess', _65 => _65.choices]), () => ( []));
 }
 function scoreGapSelect(data, response) {
   const details = [];
@@ -1719,7 +3426,7 @@ function scoreMultipleChoice(data, response) {
   let scoreValue;
   if (data.scoringStrategy === "all-or-nothing") {
     if (data.mode === "single") {
-      scoreValue = response.selectedOptionIds.length === 1 && _optionalChain([optionById, 'access', _17 => _17.get, 'call', _18 => _18(response.selectedOptionIds[0]), 'optionalAccess', _19 => _19.isCorrect]) === true ? 1 : 0;
+      scoreValue = response.selectedOptionIds.length === 1 && _optionalChain([optionById, 'access', _66 => _66.get, 'call', _67 => _67(response.selectedOptionIds[0]), 'optionalAccess', _68 => _68.isCorrect]) === true ? 1 : 0;
     } else {
       const correctIds = data.options.filter((o) => o.isCorrect).map((o) => o.id);
       const allCorrectSelected = correctIds.every((id) => selected.has(id));
@@ -1730,7 +3437,7 @@ function scoreMultipleChoice(data, response) {
     let incorrectSelected = 0;
     for (const id of selected) {
       const option = optionById.get(id);
-      if (_optionalChain([option, 'optionalAccess', _20 => _20.isCorrect])) {
+      if (_optionalChain([option, 'optionalAccess', _69 => _69.isCorrect])) {
         correctSelected += 1;
       } else {
         incorrectSelected += 1;
@@ -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.
@@ -1892,7 +3608,7 @@ var multipleChoiceType = defineActivityType({
   // exact optionals. Structurally identical at runtime — cast is type-level only.
   schema: MultipleChoiceDataSchema,
   scoring: { kind: "sync", score: scoreMultipleChoice },
-  isAnswered: (response) => (_nullishCoalesce(_optionalChain([response, 'optionalAccess', _21 => _21.selectedOptionIds, 'access', _22 => _22.length]), () => ( 0))) > 0,
+  isAnswered: (response) => (_nullishCoalesce(_optionalChain([response, 'optionalAccess', _70 => _70.selectedOptionIds, 'access', _71 => _71.length]), () => ( 0))) > 0,
   fieldPolicy: MULTIPLE_CHOICE_FIELD_POLICY,
   redactedSchema: RedactedMultipleChoiceDataSchema,
   interop: {
@@ -1909,7 +3625,7 @@ var fillInTheBlanksType = defineActivityType({
   type: "fill-in-the-blanks",
   schema: FillInTheBlanksDataSchema,
   scoring: { kind: "sync", score: scoreFillInTheBlanks },
-  isAnswered: (response) => Object.values(_nullishCoalesce(_optionalChain([response, 'optionalAccess', _23 => _23.answers]), () => ( {}))).some((answer) => answer.trim().length > 0),
+  isAnswered: (response) => Object.values(_nullishCoalesce(_optionalChain([response, 'optionalAccess', _72 => _72.answers]), () => ( {}))).some((answer) => answer.trim().length > 0),
   fieldPolicy: FILL_IN_THE_BLANKS_FIELD_POLICY,
   redactedSchema: RedactedFillInTheBlanksDataSchema,
   interop: {
@@ -1932,14 +3648,14 @@ var writtenResponseType = defineActivityType({
     kind: "deferred",
     reason: "requires_async_grading",
     partial: (data, response) => {
-      const wordCount = countWords(_nullishCoalesce(_optionalChain([response, 'optionalAccess', _24 => _24.text]), () => ( "")));
+      const wordCount = countWords(_nullishCoalesce(_optionalChain([response, 'optionalAccess', _73 => _73.text]), () => ( "")));
       return {
         withinWordBounds: response !== void 0 && wordCount >= data.minWords && wordCount <= data.maxWords,
         wordCount
       };
     }
   },
-  isAnswered: (response) => (_nullishCoalesce(_optionalChain([response, 'optionalAccess', _25 => _25.text, 'access', _26 => _26.trim, 'call', _27 => _27(), 'access', _28 => _28.length]), () => ( 0))) > 0,
+  isAnswered: (response) => (_nullishCoalesce(_optionalChain([response, 'optionalAccess', _74 => _74.text, 'access', _75 => _75.trim, 'call', _76 => _76(), 'access', _77 => _77.length]), () => ( 0))) > 0,
   fieldPolicy: WRITTEN_RESPONSE_FIELD_POLICY,
   redactedSchema: RedactedWrittenResponseDataSchema,
   interop: {
@@ -1954,7 +3670,7 @@ var gapSelectType = defineActivityType({
   type: "gap-select",
   schema: GapSelectDataSchema,
   scoring: { kind: "sync", score: scoreGapSelect },
-  isAnswered: (response) => Object.values(_nullishCoalesce(_optionalChain([response, 'optionalAccess', _29 => _29.selections]), () => ( {}))).some((choiceId) => choiceId !== ""),
+  isAnswered: (response) => Object.values(_nullishCoalesce(_optionalChain([response, 'optionalAccess', _78 => _78.selections]), () => ( {}))).some((choiceId) => choiceId !== ""),
   fieldPolicy: GAP_SELECT_FIELD_POLICY,
   redactedSchema: RedactedGapSelectDataSchema,
   interop: {
@@ -1973,10 +3689,61 @@ 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 _optionalChain([response, 'optionalAccess', _79 => _79.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, ..._nullishCoalesce(data.acceptedTranscripts, () => ( []))]
+  },
+  interactions: ["text-changed", "hint-requested", "submitted"],
+  authoring: dictationAuthoring
+});
 registerActivityType(multipleChoiceType);
 registerActivityType(fillInTheBlanksType);
 registerActivityType(writtenResponseType);
 registerActivityType(gapSelectType);
+registerActivityType(dictationType);
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 
 
 
@@ -2032,5 +3799,5 @@ registerActivityType(gapSelectType);
 
 
 
-exports.ActivitySchemaError = ActivitySchemaError; exports.UnknownActivityTypeError = UnknownActivityTypeError; exports.RedactedScoringError = RedactedScoringError; exports.DeferredScoringError = DeferredScoringError; exports.FeedbackSchema = FeedbackSchema; exports.MediaUrlSchema = MediaUrlSchema; exports.NativeControlHintSchema = NativeControlHintSchema; exports.MediaPlaybackSchema = MediaPlaybackSchema; exports.MediaSchema = MediaSchema; exports.RedactedMediaSchema = RedactedMediaSchema; exports.TextMatchPolicySchema = TextMatchPolicySchema; exports.BlankConfigSchema = BlankConfigSchema; exports.FillInTheBlanksDataSchema = FillInTheBlanksDataSchema; exports.DRAFT_ISSUE_SEVERITY = DRAFT_ISSUE_SEVERITY; exports.issue = issue; exports.isRecord = isRecord; exports.refusesEmpty = refusesEmpty; exports.isUnset = isUnset; exports.isUnwritten = isUnwritten; exports.isMissingId = isMissingId; exports.checkMedia = checkMedia; exports.covers = covers; exports.MultipleChoiceOptionMediaSchema = MultipleChoiceOptionMediaSchema; exports.MultipleChoiceOptionSchema = MultipleChoiceOptionSchema; exports.MultipleChoiceDataSchema = MultipleChoiceDataSchema; exports.countWords = countWords; exports.GapSelectChoiceSchema = GapSelectChoiceSchema; exports.GapSelectBankSchema = GapSelectBankSchema; exports.GapSelectGapSchema = GapSelectGapSchema; exports.GapSelectDataSchema = GapSelectDataSchema; exports.WrittenResponseRubricCriterionSchema = WrittenResponseRubricCriterionSchema; exports.WrittenResponseRubricSchema = WrittenResponseRubricSchema; exports.WrittenResponseDataSchema = WrittenResponseDataSchema; exports.RedactedMultipleChoiceOptionMediaSchema = RedactedMultipleChoiceOptionMediaSchema; exports.RedactedMultipleChoiceOptionSchema = RedactedMultipleChoiceOptionSchema; exports.RedactedMultipleChoiceDataSchema = RedactedMultipleChoiceDataSchema; exports.RedactedBlankConfigSchema = RedactedBlankConfigSchema; exports.RedactedFillInTheBlanksDataSchema = RedactedFillInTheBlanksDataSchema; exports.RedactedGapSelectChoiceSchema = RedactedGapSelectChoiceSchema; exports.RedactedGapSelectBankSchema = RedactedGapSelectBankSchema; exports.RedactedGapSelectGapSchema = RedactedGapSelectGapSchema; exports.RedactedGapSelectDataSchema = RedactedGapSelectDataSchema; exports.RedactedWrittenResponseDataSchema = RedactedWrittenResponseDataSchema; exports.levenshteinDistance = levenshteinDistance; exports.matchText = matchText; exports.defineActivityType = defineActivityType; exports.registerActivityType = registerActivityType; exports.getActivityTypeDescriptor = getActivityTypeDescriptor; exports.registeredActivityTypes = registeredActivityTypes; exports.MEDIA_FIELD_POLICY = MEDIA_FIELD_POLICY; exports.multipleChoiceType = multipleChoiceType; exports.fillInTheBlanksType = fillInTheBlanksType; exports.writtenResponseType = writtenResponseType;
-//# sourceMappingURL=chunk-J6POE4HL.cjs.map
+exports.ActivitySchemaError = ActivitySchemaError; exports.UnknownActivityTypeError = UnknownActivityTypeError; exports.RedactedScoringError = RedactedScoringError; exports.DeferredScoringError = DeferredScoringError; exports.withValidationScope = withValidationScope; exports.DICTATION_MAX_TRANSCRIPT_LENGTH = DICTATION_MAX_TRANSCRIPT_LENGTH; exports.DICTATION_MAX_TEXT_LENGTH = DICTATION_MAX_TEXT_LENGTH; exports.DICTATION_MAX_EQUIVALENCE_LENGTH = DICTATION_MAX_EQUIVALENCE_LENGTH; exports.DICTATION_MAX_EQUIVALENCES = DICTATION_MAX_EQUIVALENCES; exports.DICTATION_MAX_ACCEPTED_TRANSCRIPTS = DICTATION_MAX_ACCEPTED_TRANSCRIPTS; exports.FeedbackSchema = FeedbackSchema; exports.MediaUrlSchema = MediaUrlSchema; exports.NativeControlHintSchema = NativeControlHintSchema; exports.MediaPlaybackSchema = MediaPlaybackSchema; exports.MediaSchema = MediaSchema; exports.RedactedMediaSchema = RedactedMediaSchema; exports.DictationSlowMediaSchema = DictationSlowMediaSchema; exports.DictationEquivalenceSchema = DictationEquivalenceSchema; exports.DictationToleranceSchema = DictationToleranceSchema; exports.DictationDataSchema = DictationDataSchema; exports.groupCaptionsRevealDictation = groupCaptionsRevealDictation; exports.GROUP_CAPTIONS_REVEAL_DICTATION = GROUP_CAPTIONS_REVEAL_DICTATION; exports.DRAFT_ISSUE_SEVERITY = DRAFT_ISSUE_SEVERITY; exports.issue = issue; exports.isRecord = isRecord; exports.refusesEmpty = refusesEmpty; exports.isUnset = isUnset; exports.isUnwritten = isUnwritten; exports.isMissingId = isMissingId; exports.checkMedia = checkMedia; exports.covers = covers; exports.pathKey = pathKey; exports.coveredPathsOf = coveredPathsOf; exports.TextMatchPolicySchema = TextMatchPolicySchema; exports.BlankConfigSchema = BlankConfigSchema; exports.FillInTheBlanksDataSchema = FillInTheBlanksDataSchema; exports.MultipleChoiceOptionMediaSchema = MultipleChoiceOptionMediaSchema; exports.MultipleChoiceOptionSchema = MultipleChoiceOptionSchema; exports.MultipleChoiceDataSchema = MultipleChoiceDataSchema; exports.countWords = countWords; exports.GapSelectChoiceSchema = GapSelectChoiceSchema; exports.GapSelectBankSchema = GapSelectBankSchema; exports.GapSelectGapSchema = GapSelectGapSchema; exports.GapSelectDataSchema = GapSelectDataSchema; exports.WrittenResponseRubricCriterionSchema = WrittenResponseRubricCriterionSchema; exports.WrittenResponseRubricSchema = WrittenResponseRubricSchema; exports.WrittenResponseDataSchema = WrittenResponseDataSchema; exports.RedactedMultipleChoiceOptionMediaSchema = RedactedMultipleChoiceOptionMediaSchema; exports.RedactedMultipleChoiceOptionSchema = RedactedMultipleChoiceOptionSchema; exports.RedactedMultipleChoiceDataSchema = RedactedMultipleChoiceDataSchema; exports.RedactedBlankConfigSchema = RedactedBlankConfigSchema; exports.RedactedFillInTheBlanksDataSchema = RedactedFillInTheBlanksDataSchema; exports.RedactedGapSelectChoiceSchema = RedactedGapSelectChoiceSchema; exports.RedactedGapSelectBankSchema = RedactedGapSelectBankSchema; exports.RedactedGapSelectGapSchema = RedactedGapSelectGapSchema; exports.RedactedGapSelectDataSchema = RedactedGapSelectDataSchema; exports.RedactedWrittenResponseDataSchema = RedactedWrittenResponseDataSchema; exports.RedactedDictationSlowMediaSchema = RedactedDictationSlowMediaSchema; exports.RedactedDictationDataSchema = RedactedDictationDataSchema; exports.dictationReferenceWords = dictationReferenceWords; exports.alignDictation = alignDictation; exports.STEP = STEP; exports.alignSequences = alignSequences; exports.levenshteinDistance = levenshteinDistance; exports.matchText = matchText; exports.defineActivityType = defineActivityType; exports.registerActivityType = registerActivityType; exports.getActivityTypeDescriptor = getActivityTypeDescriptor; exports.registeredActivityTypes = registeredActivityTypes; exports.MEDIA_FIELD_POLICY = MEDIA_FIELD_POLICY; exports.multipleChoiceType = multipleChoiceType; exports.fillInTheBlanksType = fillInTheBlanksType; exports.writtenResponseType = writtenResponseType; exports.gapSelectType = gapSelectType; exports.dictationType = dictationType;
+//# sourceMappingURL=chunk-XONKWL6D.cjs.map