@intellectif/lk-core 1.1.0 → 1.3.0

package/dist/chunk-FBKTION6.js

@@ -1,4597 +0,0 @@
-// src/schemas/media.ts
-import { z } from "zod/v4";
-
-// src/schemas/text-length.ts
-function maxUnits(schema, max) {
-  return schema.check((payload) => {
-    if (payload.value.length > max) {
-      payload.issues.push({
-        code: "too_big",
-        origin: "string",
-        maximum: max,
-        inclusive: true,
-        input: payload.value
-      });
-    }
-  }).meta({ maxLength: max });
-}
-
-// src/schemas/media.ts
-var MediaUrlSchema = z.union([
-  z.url().refine((value) => /^(https?|data|blob):/i.test(value), {
-    error: "Absolute media URLs must use the https:, http:, data:, or blob: scheme."
-  }),
-  z.string().regex(/^\/(?!\/)\S*$/, {
-    error: 'Relative media URLs must be root-relative (a single leading "/").'
-  })
-]);
-var NativeControlHintSchema = z.enum(["hide-download", "hide-rate"]);
-var MediaPlaybackSchema = z.strictObject({
-  /**
-   * `native` (the resolved default) renders today's `<audio controls>`
-   * unchanged. `minimal` — resolved automatically whenever any enforcement
-   * field is set — replaces the browser bar with the SDK transport:
-   * play/pause, elapsed/total, mute, volume, optional speed, optional
-   * scrubber, and a live plays-remaining status.
-   */
-  controls: z.enum(["native", "minimal"]).optional(),
-  /**
-   * How many times the recording may be STARTED. A play is consumed when
-   * playback begins from anywhere other than where it last stopped, so
-   * pausing, resuming, and paging between the questions of one listening
-   * group are all free. Enforced in `practice` and `exam`; never in `review`.
-   */
-  maxPlays: z.number().int().min(1).max(20).optional(),
-  /** `none` renders no scrubber and reverts an out-of-band seek to the high-water mark. */
-  seek: z.enum(["allow", "none"]).optional(),
-  /** `fixed` renders no speed control and snaps `playbackRate` back to 1. */
-  rate: z.enum(["allow", "fixed"]).optional(),
-  /** Advisory only. See {@link NativeControlHintSchema}. */
-  nativeControlHints: z.array(NativeControlHintSchema).min(1).max(2).optional()
-});
-var MediaTrackSchema = z.strictObject({
-  kind: z.enum(["captions", "subtitles"]),
-  src: MediaUrlSchema,
-  srclang: z.string().regex(/^[A-Za-z]{2,3}(-[A-Za-z0-9]{2,8})*$/, {
-    error: 'srclang must be a BCP 47 language tag, such as "en", "es" or "pt-BR".'
-  }),
-  label: maxUnits(z.string(), 60).refine((label) => label.trim().length > 0, {
-    error: "A track label must not be empty."
-  }),
-  default: z.boolean().optional()
-});
-var MAX_TRACKS = 12;
-function posterFits(m) {
-  return m.poster === void 0 || m.type === "video";
-}
-function tracksFit(m) {
-  return m.tracks === void 0 || m.type === "audio" || m.type === "video";
-}
-function tracksAreDistinct(m) {
-  if (m.tracks === void 0) {
-    return true;
-  }
-  const defaults = m.tracks.filter((track) => track.default === true).length;
-  const keys = new Set(m.tracks.map((track) => `${track.kind}:${track.srclang.toLowerCase()}`));
-  return defaults <= 1 && keys.size === m.tracks.length;
-}
-var POSTER_FITS = { error: "poster is for video media only.", path: ["poster"] };
-var TRACKS_FIT = { error: "tracks are for audio and video media only.", path: ["tracks"] };
-var TRACKS_DISTINCT = {
-  error: "tracks: at most one may be the default, and no two may share a kind and a language \u2014 a menu listing one language twice cannot say which one it plays.",
-  path: ["tracks"]
-};
-var MediaSchema = z.looseObject({
-  type: z.enum(["image", "audio", "video", "embed"]),
-  url: MediaUrlSchema,
-  alt: z.string().min(1).optional(),
-  captionsUrl: MediaUrlSchema.optional(),
-  tracks: z.array(MediaTrackSchema).min(1).max(MAX_TRACKS).optional(),
-  poster: MediaUrlSchema.optional(),
-  playback: MediaPlaybackSchema.optional()
-}).refine(
-  (m) => m.type !== "image" && m.type !== "embed" || typeof m.alt === "string" && m.alt.length > 0,
-  {
-    error: "image and embed media require non-empty alt text (WCAG 1.1.1 / 4.1.2).",
-    path: ["alt"]
-  }
-).refine((m) => m.type !== "embed" || /^https?:\/\//i.test(m.url), {
-  error: "embed media requires an absolute http(s) provider URL. data:, blob:, and relative URLs are not allowed for embeds \u2014 the embed iframe runs with allow-scripts, and a data:/same-origin document there is an XSS vector.",
-  path: ["url"]
-}).refine(posterFits, POSTER_FITS).refine(tracksFit, TRACKS_FIT).refine(tracksAreDistinct, TRACKS_DISTINCT).refine((m) => m.playback === void 0 || m.type === "audio", {
-  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) => m.playback?.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) => m.playback?.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) => m.playback?.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) => m.playback?.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"]
-  }
-);
-var RedactedMediaSchema = z.strictObject({
-  type: z.enum(["image", "audio", "video", "embed"]),
-  url: MediaUrlSchema,
-  alt: z.string().min(1).optional(),
-  captionsUrl: MediaUrlSchema.optional(),
-  tracks: z.array(MediaTrackSchema).min(1).max(MAX_TRACKS).optional(),
-  poster: MediaUrlSchema.optional(),
-  playback: MediaPlaybackSchema.optional()
-}).refine(
-  (m) => m.type !== "image" && m.type !== "embed" || typeof m.alt === "string" && m.alt.length > 0,
-  {
-    error: "image and embed media require non-empty alt text (WCAG 1.1.1 / 4.1.2).",
-    path: ["alt"]
-  }
-).refine((m) => m.type !== "embed" || /^https?:\/\//i.test(m.url), {
-  error: "embed media requires an absolute http(s) provider URL. data:, blob:, and relative URLs are not allowed for embeds \u2014 the embed iframe runs with allow-scripts, and a data:/same-origin document there is an XSS vector.",
-  path: ["url"]
-}).refine(posterFits, POSTER_FITS).refine(tracksFit, TRACKS_FIT).refine(tracksAreDistinct, TRACKS_DISTINCT);
-
-// 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 UNSPACED_LETTER_RE = new RegExp(`(?=\\p{L})${UNSPACED_CHARACTER}`, "u");
-function containsUnspacedScript(text) {
-  return UNSPACED_LETTER_RE.test(text);
-}
-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/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/errors.ts
-var ActivitySchemaError = class extends Error {
-  constructor(activityType, errors) {
-    super(`Invalid activity data for type "${activityType}"`);
-    this.activityType = activityType;
-    this.errors = errors;
-    this.name = "ActivitySchemaError";
-  }
-  activityType;
-  errors;
-};
-var UnknownActivityTypeError = class extends Error {
-  constructor(activityType) {
-    super(`Activity type "${activityType}" is not registered`);
-    this.activityType = activityType;
-    this.name = "UnknownActivityTypeError";
-  }
-  activityType;
-};
-var RedactedScoringError = class extends Error {
-  constructor(activityType) {
-    super(
-      `Activity data for "${activityType}" carries no answer key (it looks redacted), so it cannot be scored. Score against the full activity data server-side. evaluate() answers this input without throwing, but it never grades it.`
-    );
-    this.activityType = activityType;
-    this.name = "RedactedScoringError";
-  }
-  activityType;
-};
-var DeferredScoringError = class extends Error {
-  constructor(activityType) {
-    super(
-      `Activity type "${activityType}" is graded asynchronously and has no synchronous score. Use evaluate() \u2014 it returns { status: 'deferred' } for this type.`
-    );
-    this.activityType = activityType;
-    this.name = "DeferredScoringError";
-  }
-  activityType;
-};
-
-// src/schemas/multiple-choice.ts
-import { z as z4 } from "zod/v4";
-
-// src/schemas/ai.ts
-import { z as z2 } from "zod/v4";
-var AiPermissionsSchema = z2.looseObject({
-  explanations: z2.boolean().optional(),
-  hints: z2.boolean().optional()
-});
-
-// src/schemas/feedback.ts
-import { z as z3 } from "zod/v4";
-var FeedbackSchema = z3.looseObject({
-  correct: z3.string().min(1).optional(),
-  incorrect: z3.string().min(1).optional()
-});
-
-// src/schemas/multiple-choice.ts
-var MultipleChoiceOptionMediaSchema = z4.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"]),
-  url: MediaUrlSchema,
-  alt: z4.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`.",
-  path: ["alt"]
-}).refine((media) => !("playback" in media), {
-  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(),
-  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"]),
-  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(),
-  ai: AiPermissionsSchema.optional()
-}).refine((data) => data.options.some((option) => option.isCorrect), {
-  error: "At least one option must be marked correct.",
-  path: ["options"]
-}).refine(
-  (data) => data.mode !== "single" || data.options.filter((option) => option.isCorrect).length === 1,
-  {
-    error: 'Single-select activities (mode: "single") must have exactly one correct option.',
-    path: ["options"]
-  }
-).refine((data) => new Set(data.options.map((option) => option.id)).size === data.options.length, {
-  error: "Option ids must be unique within the activity.",
-  path: ["options"]
-});
-
-// src/scoring/speech/limits.ts
-var READ_ALOUD_MAX_REFERENCE_LENGTH = DICTATION_MAX_TRANSCRIPT_LENGTH;
-var READ_ALOUD_MAX_SECONDS = 300;
-var READ_ALOUD_MAX_TAKES = 20;
-var READ_ALOUD_MAX_DIMENSION_WEIGHT = 1e3;
-var SPEECH_ASSESSMENT_MAX_WORDS = 1e3;
-var SPEECH_ASSESSMENT_MAX_TEXT_LENGTH = DICTATION_MAX_TEXT_LENGTH;
-
-// src/count-words.ts
-function countWords(text) {
-  if (typeof text !== "string") {
-    return 0;
-  }
-  const trimmed = text.trim();
-  if (trimmed === "") {
-    return 0;
-  }
-  return trimmed.split(/\s+/).length;
-}
-
-// src/schemas/read-schema.ts
-var OWN_SCHEMAS = /* @__PURE__ */ new WeakSet();
-function ownSchemas(...schemas) {
-  for (const schema of schemas) {
-    OWN_SCHEMAS.add(schema);
-  }
-}
-function isOwnSchema(schema) {
-  return OWN_SCHEMAS.has(schema);
-}
-var GENERIC_CODE = "invalid";
-function valueAt(root, path) {
-  let node = root;
-  for (const segment of path) {
-    if (node === null || typeof node !== "object") {
-      return void 0;
-    }
-    node = node[segment];
-  }
-  return node;
-}
-var isThenable = (value) => typeof value?.then === "function";
-function isZodSchema(schema) {
-  return schema["~standard"].vendor === "zod" && typeof schema.safeParse === "function";
-}
-function readSchema(schema, value, subject, options) {
-  if (isZodSchema(schema)) {
-    const parsed = schema.safeParse(
-      value,
-      options?.reportInput === true ? { reportInput: true } : void 0
-    );
-    if (parsed.success) {
-      return { success: true, data: parsed.data };
-    }
-    return {
-      success: false,
-      issues: parsed.error.issues.map((issue2) => ({
-        path: issue2.path,
-        message: issue2.message,
-        code: issue2.code,
-        ..."input" in issue2 ? { input: issue2.input } : {}
-      }))
-    };
-  }
-  const result = schema["~standard"].validate(value);
-  if (isThenable(result)) {
-    result.then(void 0, () => {
-    });
-    throw new TypeError(
-      `${subject} has a schema whose validation returned a Promise: it validates asynchronously, or its library reported an error that way. lk-core validates synchronously: register a schema whose validation returns its result.`
-    );
-  }
-  const settled = result;
-  if (settled.issues === void 0) {
-    return { success: true, data: settled.value };
-  }
-  return {
-    success: false,
-    issues: settled.issues.map((issue2) => {
-      const path = (issue2.path ?? []).map(
-        (segment) => typeof segment === "object" && segment !== null ? segment.key : segment
-      );
-      const code = issue2.code;
-      return {
-        path,
-        message: issue2.message,
-        code: typeof code === "string" && code !== "" ? code : GENERIC_CODE,
-        input: valueAt(value, path)
-      };
-    })
-  };
-}
-function isStandardSchema(value) {
-  const props = value?.["~standard"];
-  return props?.version === 1 && typeof props.validate === "function";
-}
-function standardJsonSchemaOf(schema) {
-  const converter = schema["~standard"].jsonSchema;
-  if (typeof converter?.output !== "function") {
-    return void 0;
-  }
-  const generated = converter.output({ target: "draft-07" });
-  return generated !== null && typeof generated === "object" && !Array.isArray(generated) ? generated : void 0;
-}
-
-// src/scoring/text-match.ts
-var COMBINING_MARKS_RE = /\p{M}/gu;
-var PUNCTUATION_RE2 = /\p{P}/gu;
-function applyBaseline(value, policy) {
-  let result = value;
-  if (policy.trim !== false) {
-    result = result.trim();
-  }
-  if (policy.caseSensitive !== true) {
-    result = policy.locale ? result.toLocaleLowerCase(policy.locale) : result.toLowerCase();
-  }
-  return result;
-}
-function applyNormalization(value, policy) {
-  let result = value;
-  if (policy.normalize === "NFC" || policy.normalize === "NFKC") {
-    result = result.normalize(policy.normalize);
-  }
-  if (policy.ignorePunctuation === true) {
-    result = result.replace(PUNCTUATION_RE2, "");
-  }
-  if (policy.collapseInnerWhitespace === true) {
-    result = result.replace(/(?<=\S)\s+(?=\S)/g, " ");
-    if (policy.trim !== false) {
-      result = result.trim();
-    }
-  }
-  return result;
-}
-function applyDiacriticFold(value) {
-  return value.normalize("NFD").replace(COMBINING_MARKS_RE, "").normalize("NFC");
-}
-function levenshteinDistance(a, b, max) {
-  if (a === b) return 0;
-  if (Math.abs(a.length - b.length) > max) return max + 1;
-  if (a.length === 0) return b.length;
-  if (b.length === 0) return a.length;
-  let previous = Array.from({ length: b.length + 1 }, (_, i) => i);
-  for (let i = 1; i <= a.length; i += 1) {
-    const current = [i];
-    let rowMin = i;
-    for (let j = 1; j <= b.length; j += 1) {
-      const cost = a[i - 1] === b[j - 1] ? 0 : 1;
-      const value = Math.min(
-        previous[j] + 1,
-        current[j - 1] + 1,
-        previous[j - 1] + cost
-      );
-      current.push(value);
-      if (value < rowMin) rowMin = value;
-    }
-    if (rowMin > max) return max + 1;
-    previous = current;
-  }
-  return previous[b.length];
-}
-function matchText(input, accepted, policy = {}) {
-  const acceptedList = typeof accepted === "string" ? [accepted] : accepted;
-  const baselineInput = applyBaseline(input, policy);
-  const baselineAccepted = acceptedList.map((answer) => applyBaseline(answer, policy));
-  if (baselineAccepted.some((answer) => answer === baselineInput)) {
-    return { matched: true, via: "exact" };
-  }
-  const usesNormalization = policy.normalize === "NFC" || policy.normalize === "NFKC" || policy.ignorePunctuation === true || policy.collapseInnerWhitespace === true;
-  const normalizedInput = usesNormalization ? applyNormalization(baselineInput, policy) : baselineInput;
-  const normalizedAccepted = usesNormalization ? baselineAccepted.map((answer) => applyNormalization(answer, policy)) : baselineAccepted;
-  if (usesNormalization && normalizedAccepted.some((answer) => answer === normalizedInput)) {
-    return { matched: true, via: "normalized" };
-  }
-  const foldedInput = policy.foldDiacritics === true ? applyDiacriticFold(normalizedInput) : normalizedInput;
-  const foldedAccepted = policy.foldDiacritics === true ? normalizedAccepted.map((answer) => applyDiacriticFold(answer)) : normalizedAccepted;
-  if (policy.foldDiacritics === true && foldedAccepted.some((answer) => answer === foldedInput)) {
-    return { matched: true, via: "folded" };
-  }
-  const maxDistance = policy.levenshtein ?? 0;
-  if (maxDistance > 0 && foldedInput.trim().length > 0 && foldedAccepted.some(
-    (answer) => levenshteinDistance(foldedInput, answer, maxDistance) <= maxDistance
-  )) {
-    return { matched: true, via: "fuzzy" };
-  }
-  return { matched: false, via: "none" };
-}
-
-// src/registry/registry.ts
-var registry = /* @__PURE__ */ new Map();
-function defineActivityType(descriptor) {
-  return descriptor;
-}
-function registerActivityType(descriptor) {
-  if (descriptor.type === "item-group") {
-    throw new Error(
-      `"item-group" is reserved for the SDK's item-group container (see ItemGroup) and cannot be registered as an activity type.`
-    );
-  }
-  if (!isStandardSchema(descriptor.schema)) {
-    throw new TypeError(
-      `Activity type "${descriptor.type}": \`schema\` must implement Standard Schema v1 (https://standardschema.dev), as a zod 4, valibot or ArkType schema does.`
-    );
-  }
-  if (descriptor.redactedSchema !== void 0 && !isStandardSchema(descriptor.redactedSchema)) {
-    throw new TypeError(
-      `Activity type "${descriptor.type}": \`redactedSchema\` must implement Standard Schema v1 (https://standardschema.dev), as a zod 4, valibot or ArkType schema does.`
-    );
-  }
-  if (descriptor.jsonSchema !== void 0 && (descriptor.jsonSchema === null || typeof descriptor.jsonSchema !== "object" || Array.isArray(descriptor.jsonSchema))) {
-    throw new TypeError(
-      `Activity type "${descriptor.type}": \`jsonSchema\` must be a JSON Schema object.`
-    );
-  }
-  const existing = registry.get(descriptor.type);
-  if (existing !== void 0) {
-    if (existing === descriptor) {
-      return;
-    }
-    throw new Error(
-      `Activity type "${descriptor.type}" is already registered. Registering a different descriptor for an existing type is not allowed.`
-    );
-  }
-  registry.set(descriptor.type, descriptor);
-}
-function getActivityTypeDescriptor(type) {
-  return registry.get(type);
-}
-function registeredActivityTypes() {
-  return [...registry.keys()];
-}
-
-// src/schemas/dictation.ts
-import { z as z6 } from "zod/v4";
-
-// src/schemas/after-issues.ts
-import { z as z5 } from "zod/v4";
-function checkEvenAfterIssues(check) {
-  const guard = new z5.core.$ZodCheck({ check: "custom", when: () => true });
-  guard._zod.check = check;
-  return guard;
-}
-function parsedFields(payload) {
-  const refused = new Set(payload.issues.map((issue2) => String(issue2.path?.[0])));
-  const data = { ...payload.value };
-  for (const key of refused) {
-    delete data[key];
-  }
-  return { data, refused };
-}
-
-// src/schemas/dictation.ts
-var DictationSlowMediaSchema = z6.looseObject({
-  type: z6.literal("audio"),
-  url: MediaUrlSchema,
-  alt: z6.string().min(1).optional()
-});
-var RuleTextSchema = z6.string().min(1).meta({ maxLength: DICTATION_MAX_EQUIVALENCE_LENGTH });
-var TranscriptTextSchema = z6.string().min(1).meta({ maxLength: DICTATION_MAX_TRANSCRIPT_LENGTH });
-var DictationEquivalenceSchema = z6.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 = z6.looseObject({
-  equivalences: z6.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, ...data.acceptedTranscripts ?? []];
-}
-function isEmpty(measured) {
-  return measured.normalized === "";
-}
-var DictationDataShape = z6.looseObject({
-  schemaVersion: z6.literal("1.0"),
-  type: z6.literal("dictation"),
-  id: z6.string().min(1),
-  title: z6.string().min(1),
-  transcript: TranscriptTextSchema,
-  acceptedTranscripts: z6.array(TranscriptTextSchema).max(DICTATION_MAX_ACCEPTED_TRANSCRIPTS).optional(),
-  media: MediaSchema.optional(),
-  slowMedia: DictationSlowMediaSchema.optional(),
-  hints: z6.looseObject({ mode: z6.literal("progressive-words") }).optional(),
-  tolerance: DictationToleranceSchema.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(),
-  ai: AiPermissionsSchema.optional()
-});
-var DictationDataSchema = DictationDataShape.check(
-  checkEvenAfterIssues((ctx) => {
-    if (ctx.issues.some((issue2) => (issue2.path?.length ?? 0) === 0)) {
-      return;
-    }
-    const { data, refused } = parsedFields(ctx);
-    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];
-      for (const captions of captionFieldsOf(recording)) {
-        report(
-          [field, captions],
-          recording?.[captions],
-          "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.'
-        );
-      }
-    }
-  })
-);
-var isObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
-function captionFieldsOf(media, written = (captionsUrl) => captionsUrl !== void 0) {
-  if (!isObject(media)) {
-    return [];
-  }
-  const fields = [];
-  if (written(media.captionsUrl)) {
-    fields.push("captionsUrl");
-  }
-  if (Array.isArray(media.tracks) && media.tracks.length > 0) {
-    fields.push("tracks");
-  }
-  return fields;
-}
-function groupCaptionsField(group, written) {
-  if (!isObject(group) || !isObject(group.stimulus) || !Array.isArray(group.items)) {
-    return void 0;
-  }
-  const [field] = captionFieldsOf(group.stimulus.media, written);
-  if (field === void 0) {
-    return void 0;
-  }
-  const played = group.items.some(
-    (item) => isObject(item) && item.type === "dictation" && item.media === void 0
-  );
-  return played ? field : 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/authoring/issues.ts
-var DRAFT_ISSUE_SEVERITY = {
-  // Every registered type — reported by validateDraft itself
-  null_not_allowed: "invalid",
-  // Every built-in activity
-  schema_version_invalid: "invalid",
-  type_mismatch: "invalid",
-  id_required: "invalid",
-  title_required: "incomplete",
-  scoring_strategy_required: "incomplete",
-  pass_threshold_invalid: "invalid",
-  difficulty_level_invalid: "invalid",
-  ai_permissions_invalid: "invalid",
-  feedback_empty: "incomplete",
-  redacted_data: "invalid",
-  media_type_required: "incomplete",
-  media_url_required: "incomplete",
-  media_url_invalid: "invalid",
-  media_alt_required: "incomplete",
-  media_playback_invalid: "invalid",
-  media_invalid: "invalid",
-  // multiple-choice
-  mc_question_required: "incomplete",
-  mc_mode_required: "incomplete",
-  mc_options_too_few: "incomplete",
-  mc_options_too_many: "invalid",
-  mc_option_id_required: "invalid",
-  mc_option_id_duplicate: "invalid",
-  mc_option_text_required: "incomplete",
-  mc_option_correctness_required: "incomplete",
-  mc_option_media_kind: "invalid",
-  mc_correct_option_required: "incomplete",
-  mc_single_mode_one_correct: "invalid",
-  // fill-in-the-blanks
-  fib_passage_required: "incomplete",
-  fib_blanks_required: "incomplete",
-  fib_blank_id_required: "invalid",
-  fib_blank_id_duplicate: "invalid",
-  fib_accepted_answers_required: "incomplete",
-  fib_accepted_answer_empty: "incomplete",
-  fib_levenshtein_invalid: "invalid",
-  fib_match_locale_invalid: "invalid",
-  fib_match_invalid: "invalid",
-  fib_blank_missing: "incomplete",
-  fib_placeholder_missing: "incomplete",
-  fib_placeholder_duplicate: "invalid",
-  fib_blanks_mismatch: "invalid",
-  // item-group (the testlet container, via validateItemGroupDraft)
-  ig_not_an_object: "invalid",
-  ig_stimulus_required: "incomplete",
-  ig_stimulus_id_required: "invalid",
-  ig_stimulus_kind_required: "incomplete",
-  ig_stimulus_kind_invalid: "invalid",
-  ig_stimulus_body_required: "incomplete",
-  ig_stimulus_media_required: "incomplete",
-  ig_stimulus_media_kind: "invalid",
-  ig_items_required: "incomplete",
-  ig_item_id_required: "invalid",
-  ig_item_id_duplicate: "invalid",
-  ig_item_type_required: "incomplete",
-  ig_item_type_unknown: "invalid",
-  ig_item_nested_group: "invalid",
-  ig_shuffle_invalid: "invalid",
-  // interactive video (an item group with a timeline)
-  ig_timeline_stimulus_kind: "invalid",
-  ig_timeline_shuffle: "invalid",
-  ig_timeline_quiz_id_required: "incomplete",
-  ig_timeline_quiz_id_duplicate: "invalid",
-  ig_timeline_quiz_time_required: "incomplete",
-  ig_timeline_quiz_time_invalid: "invalid",
-  ig_timeline_quiz_empty: "incomplete",
-  ig_timeline_quiz_unknown_item: "invalid",
-  ig_timeline_item_duplicate: "invalid",
-  ig_timeline_item_unplaced: "incomplete",
-  ig_timeline_item_type: "invalid",
-  ig_timeline_dictation_media: "incomplete",
-  ig_timeline_chapter_order: "invalid",
-  ig_timeline_chapter_title: "incomplete",
-  // gap-select
-  gs_passage_required: "incomplete",
-  gs_gaps_required: "incomplete",
-  gs_gap_id_required: "invalid",
-  gs_gap_id_duplicate: "invalid",
-  gs_gap_missing: "incomplete",
-  gs_placeholder_missing: "incomplete",
-  gs_placeholder_duplicate: "invalid",
-  gs_gaps_mismatch: "invalid",
-  gs_presentation_invalid: "invalid",
-  gs_bank_id_required: "invalid",
-  gs_bank_id_duplicate: "invalid",
-  gs_bank_unknown: "invalid",
-  gs_choice_source_required: "incomplete",
-  gs_choice_source_conflict: "invalid",
-  gs_choices_too_few: "incomplete",
-  gs_choice_id_required: "invalid",
-  gs_choice_id_duplicate: "invalid",
-  gs_choice_text_required: "incomplete",
-  gs_correct_choice_required: "incomplete",
-  gs_correct_choice_unknown: "invalid",
-  // written-response
-  wr_prompt_required: "incomplete",
-  wr_min_words_required: "incomplete",
-  wr_min_words_invalid: "invalid",
-  wr_max_words_required: "incomplete",
-  wr_max_words_invalid: "invalid",
-  wr_word_bounds_order: "invalid",
-  wr_rubric_criteria_required: "incomplete",
-  wr_criterion_name_required: "incomplete",
-  wr_criterion_weight_required: "incomplete",
-  wr_criterion_weight_invalid: "invalid",
-  wr_rubric_weights_zero: "incomplete",
-  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",
-  // read-aloud
-  ra_reference_text_required: "incomplete",
-  ra_reference_text_too_long: "invalid",
-  ra_reference_text_unreadable: "invalid",
-  ra_reference_text_unspaced_script: "invalid",
-  ra_locale_required: "incomplete",
-  ra_locale_invalid: "invalid",
-  ra_max_seconds_required: "incomplete",
-  ra_max_seconds_out_of_range: "invalid",
-  ra_min_seconds_out_of_range: "invalid",
-  ra_max_takes_out_of_range: "invalid",
-  ra_dimensions_required: "incomplete",
-  ra_dimension_name_invalid: "invalid",
-  ra_dimension_duplicate: "invalid",
-  ra_dimension_weight_invalid: "invalid",
-  ra_dimension_weights_zero: "invalid",
-  ra_media_kind: "invalid",
-  ra_slow_media_without_media: "incomplete",
-  ra_slow_media_same_recording: "invalid",
-  ra_slow_media_beside_play_limit: "invalid"
-};
-function issue(code, path, message) {
-  return { path: path.map(String), message, code, severity: DRAFT_ISSUE_SEVERITY[code] };
-}
-function isRecord(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function valueAt2(root, path) {
-  let node = root;
-  for (const segment of path) {
-    if (typeof node !== "object" || node === null) {
-      return void 0;
-    }
-    node = node[segment];
-  }
-  return node;
-}
-function refusesEmpty(root, schemaIssue) {
-  const { path } = schemaIssue;
-  const value = valueAt2(root, path);
-  const index = path.at(-1);
-  const list = valueAt2(root, path.slice(0, -1));
-  const empty = value === null || value === void 0 && typeof index === "number" && Array.isArray(list) && index < list.length;
-  return empty && (schemaIssue.input === value || schemaIssue.code === "invalid_union");
-}
-function isUnset(value) {
-  return value === void 0 || value === null;
-}
-function isUnwritten(value) {
-  return isUnset(value) || typeof value === "string" && value.trim() === "";
-}
-function isMissingId(value) {
-  return isUnset(value) || value === "";
-}
-function isWholeNumber(value) {
-  return typeof value === "number" && Number.isSafeInteger(value);
-}
-function isTooLarge(value) {
-  return typeof value === "number" && value > Number.MAX_SAFE_INTEGER && Number.isInteger(value);
-}
-function checkIdentity(draft, type) {
-  const issues = [];
-  if (draft.schemaVersion !== "1.0") {
-    issues.push(
-      issue(
-        "schema_version_invalid",
-        ["schemaVersion"],
-        'The draft must have schemaVersion "1.0". A draft from createDraft has it.'
-      )
-    );
-  }
-  if (draft.type !== type) {
-    issues.push(issue("type_mismatch", ["type"], `The draft's type must be "${type}".`));
-  }
-  if (isMissingId(draft.id)) {
-    issues.push(issue("id_required", ["id"], "The activity has no id."));
-  }
-  if (isUnwritten(draft.title)) {
-    issues.push(issue("title_required", ["title"], "Add a title."));
-  }
-  return issues;
-}
-function checkScoringStrategy(draft) {
-  return isUnwritten(draft.scoringStrategy) ? [
-    issue(
-      "scoring_strategy_required",
-      ["scoringStrategy"],
-      "Choose how the question is scored."
-    )
-  ] : [];
-}
-var DIFFICULTY_LEVELS = [1, 2, 3, 4, 5];
-function checkSharedOptional(draft) {
-  const issues = [];
-  const threshold = draft.passThreshold;
-  if (!isUnset(threshold) && !(typeof threshold === "number" && threshold >= 0 && threshold <= 1)) {
-    issues.push(
-      issue(
-        "pass_threshold_invalid",
-        ["passThreshold"],
-        "The pass threshold must be a number from 0 to 1."
-      )
-    );
-  }
-  if (!isUnset(draft.difficultyLevel) && !DIFFICULTY_LEVELS.includes(draft.difficultyLevel)) {
-    issues.push(
-      issue(
-        "difficulty_level_invalid",
-        ["difficultyLevel"],
-        "The difficulty level must be a whole number from 1 to 5."
-      )
-    );
-  }
-  const ai = draft.ai;
-  if (!isUnset(ai)) {
-    if (!isRecord(ai)) {
-      issues.push(
-        issue(
-          "ai_permissions_invalid",
-          ["ai"],
-          "AI permissions must be an object of on/off flags, such as { hints: false }."
-        )
-      );
-    } else {
-      for (const key of ["explanations", "hints"]) {
-        if (!isUnset(ai[key]) && typeof ai[key] !== "boolean") {
-          issues.push(
-            issue(
-              "ai_permissions_invalid",
-              ["ai", key],
-              "Set this to true or false, or remove it."
-            )
-          );
-        }
-      }
-    }
-  }
-  const feedback = draft.feedback;
-  if (isRecord(feedback)) {
-    for (const key of ["correct", "incorrect"]) {
-      const message = feedback[key];
-      if (typeof message === "string" && message.trim() === "") {
-        issues.push(
-          issue("feedback_empty", ["feedback", key], "Write this feedback message, or remove it.")
-        );
-      }
-    }
-  }
-  if (draft.redacted === true) {
-    issues.push(
-      issue(
-        "redacted_data",
-        ["redacted"],
-        "This is a copy prepared for learners, with the answer key removed. Edit the original activity instead."
-      )
-    );
-  }
-  if (isRecord(draft.media)) {
-    issues.push(...checkMedia(draft.media));
-  }
-  return issues;
-}
-var URL_POLICY = 'Use an https:, http:, data: or blob: address, or a path on the same site that starts with a single "/".';
-var EMBED_URL = "An embed needs the provider's full http(s) embed address, such as https://www.youtube.com/embed/VIDEO_ID.";
-function checkMedia(media, prefix = ["media"], schema = MediaSchema) {
-  const issues = [];
-  const at = (...rest) => [...prefix, ...rest];
-  const parsed = schema.safeParse(media, { reportInput: true });
-  const schemaIssues = parsed.success ? [] : parsed.error.issues.filter((found) => !refusesEmpty(media, found));
-  const refusal = (field) => schemaIssues.find((found) => found.path[0] === field);
-  const typeUnset = isUnwritten(media.type);
-  if (typeUnset) {
-    issues.push(issue("media_type_required", at("type"), "Choose what kind of media this is."));
-  }
-  if (isUnwritten(media.url)) {
-    issues.push(issue("media_url_required", at("url"), "Add the address of the media file."));
-  } else {
-    const refused = refusal("url");
-    if (refused !== void 0) {
-      issues.push(
-        issue("media_url_invalid", at("url"), refused.code === "custom" ? EMBED_URL : URL_POLICY)
-      );
-    }
-  }
-  const needsAlt = media.type === "image" || media.type === "embed";
-  const alt = media.alt;
-  if (needsAlt && isUnwritten(alt) || typeof alt === "string" && alt.trim() === "") {
-    issues.push(issue("media_alt_required", at("alt"), "Add a text description of the media."));
-  }
-  const captions = media.captionsUrl;
-  if (typeof captions === "string" && captions.trim() === "") {
-    issues.push(
-      issue(
-        "media_url_required",
-        at("captionsUrl"),
-        "Add the address of the captions file, or remove the captions."
-      )
-    );
-  } else if (refusal("captionsUrl") !== void 0) {
-    issues.push(issue("media_url_invalid", at("captionsUrl"), URL_POLICY));
-  }
-  for (const schemaIssue of schemaIssues) {
-    const field = schemaIssue.path[0];
-    if (field === "url" || field === "alt" || field === "captionsUrl" || field === "type" && typeUnset) {
-      continue;
-    }
-    issues.push(
-      issue(
-        field === "playback" ? "media_playback_invalid" : "media_invalid",
-        at(...schemaIssue.path.map(String)),
-        schemaIssue.message
-      )
-    );
-  }
-  return issues;
-}
-function covers(reported, failed) {
-  if (failed.length === 0) {
-    return reported.length === 0;
-  }
-  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."
-      )
-    );
-  }
-  for (const captions of captionFieldsOf(media, (captionsUrl) => !isUnset(captionsUrl))) {
-    issues.push(issue("dc_captions_not_allowed", ["media", captions], 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
-    )
-  );
-  for (const captions of captionFieldsOf(slow, (captionsUrl) => !isUnset(captionsUrl))) {
-    issues.push(issue("dc_captions_not_allowed", ["slowMedia", captions], 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/schemas/fill-in-the-blanks.ts
-import { z as z7 } from "zod/v4";
-var PLACEHOLDER_RE = /\{\{\s*([^{}]+?)\s*\}\}/g;
-var TextMatchPolicySchema = z7.looseObject({
-  caseSensitive: z7.boolean().optional(),
-  trim: z7.boolean().optional(),
-  normalize: z7.enum(["none", "NFC", "NFKC"]).optional(),
-  foldDiacritics: z7.boolean().optional(),
-  collapseInnerWhitespace: z7.boolean().optional(),
-  ignorePunctuation: z7.boolean().optional(),
-  levenshtein: z7.number().int().min(0).optional(),
-  locale: z7.string().optional()
-});
-var BlankConfigSchema = z7.looseObject({
-  id: z7.string().min(1),
-  acceptedAnswers: z7.array(
-    z7.string().min(1).refine((answer) => answer.trim().length > 0, {
-      error: "Accepted answers must contain non-whitespace characters."
-    })
-  ).min(1),
-  caseSensitive: z7.boolean().optional(),
-  trimWhitespace: z7.boolean().optional(),
-  match: TextMatchPolicySchema.optional(),
-  hint: z7.string().optional(),
-  feedback: z7.string().optional()
-});
-var FillInTheBlanksDataSchema = z7.looseObject({
-  schemaVersion: z7.literal("1.0"),
-  type: z7.literal("fill-in-the-blanks"),
-  id: z7.string().min(1),
-  title: z7.string().min(1),
-  passage: z7.string().min(1),
-  passageHtml: z7.string().optional(),
-  blanks: z7.array(BlankConfigSchema).min(1),
-  scoringStrategy: z7.enum(["all-or-nothing", "partial"]),
-  media: MediaSchema.optional(),
-  feedback: FeedbackSchema.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(),
-  ai: AiPermissionsSchema.optional()
-}).refine(
-  (data) => {
-    const placeholderCounts2 = /* @__PURE__ */ new Map();
-    for (const match of data.passage.matchAll(PLACEHOLDER_RE)) {
-      const id = match[1];
-      placeholderCounts2.set(id, (placeholderCounts2.get(id) ?? 0) + 1);
-    }
-    const blankIds = data.blanks.map((blank) => blank.id);
-    if (new Set(blankIds).size !== blankIds.length) {
-      return false;
-    }
-    if (placeholderCounts2.size !== blankIds.length) {
-      return false;
-    }
-    return blankIds.every((id) => placeholderCounts2.get(id) === 1);
-  },
-  {
-    error: "Each blank id must appear exactly once in blanks[] and have exactly one matching {{id}} placeholder in the passage, and vice versa.",
-    path: ["passage"]
-  }
-);
-
-// src/authoring/fill-in-the-blanks.ts
-var fillInTheBlanksAuthoring = {
-  createDraft: ({ newId }) => ({
-    schemaVersion: "1.0",
-    type: "fill-in-the-blanks",
-    id: newId(),
-    title: "",
-    passage: "",
-    blanks: [],
-    scoringStrategy: "all-or-nothing"
-  }),
-  checkDraft: checkFillInTheBlanksDraft
-};
-function checkFillInTheBlanksDraft(draft) {
-  const issues = checkIdentity(draft, "fill-in-the-blanks");
-  const passage = draft.passage;
-  if (isUnwritten(passage)) {
-    issues.push(issue("fib_passage_required", ["passage"], "Write the passage."));
-  }
-  issues.push(...checkScoringStrategy(draft));
-  const blanks = isUnset(draft.blanks) ? [] : draft.blanks;
-  if (Array.isArray(blanks)) {
-    if (blanks.length === 0) {
-      issues.push(
-        issue(
-          "fib_blanks_required",
-          ["blanks"],
-          "Add at least one blank, and mark where it goes in the passage with {{id}}."
-        )
-      );
-    }
-    const ids = [];
-    for (const [index, blank] of blanks.entries()) {
-      if (!isRecord(blank)) {
-        continue;
-      }
-      const name = typeof blank.id === "string" && blank.id !== "" ? `"${blank.id}"` : index + 1;
-      if (isMissingId(blank.id)) {
-        issues.push(
-          issue("fib_blank_id_required", ["blanks", index, "id"], `Blank ${index + 1} has no id.`)
-        );
-      } else if (typeof blank.id === "string") {
-        ids.push(blank.id);
-      }
-      const answers = isUnset(blank.acceptedAnswers) ? [] : blank.acceptedAnswers;
-      if (Array.isArray(answers)) {
-        if (answers.length === 0) {
-          issues.push(
-            issue(
-              "fib_accepted_answers_required",
-              ["blanks", index, "acceptedAnswers"],
-              `Add an accepted answer for blank ${name}.`
-            )
-          );
-        }
-        for (const [position, answer] of answers.entries()) {
-          if (typeof answer === "string" && answer.trim() === "") {
-            issues.push(
-              issue(
-                "fib_accepted_answer_empty",
-                ["blanks", index, "acceptedAnswers", position],
-                `An accepted answer for blank ${name} is empty. Fill it in or remove it.`
-              )
-            );
-          }
-        }
-      }
-      if (isRecord(blank.match)) {
-        issues.push(...checkMatch(blank.match, index));
-      }
-    }
-    if (typeof passage === "string" && passage.trim() !== "") {
-      issues.push(...checkPairing(passage, blanks, ids));
-    }
-  }
-  issues.push(...checkSharedOptional(draft));
-  return issues;
-}
-function checkMatch(match, index) {
-  const issues = [];
-  const at = (...rest) => ["blanks", index, "match", ...rest];
-  const tolerance = match.levenshtein;
-  if (!isUnset(tolerance) && !(isWholeNumber(tolerance) && tolerance >= 0)) {
-    issues.push(
-      issue(
-        "fib_levenshtein_invalid",
-        at("levenshtein"),
-        isTooLarge(tolerance) ? "Typo tolerance is too large." : "Typo tolerance must be a whole number, 0 or more."
-      )
-    );
-  }
-  const locale = match.locale;
-  if (typeof locale === "string" && locale !== "" && !isLanguageTag(locale)) {
-    issues.push(
-      issue(
-        "fib_match_locale_invalid",
-        at("locale"),
-        `"${locale}" is not a language tag. Use one such as "tr" or "en-US", or leave the locale out.`
-      )
-    );
-  }
-  const parsed = TextMatchPolicySchema.safeParse(match, { reportInput: true });
-  if (!parsed.success) {
-    for (const schemaIssue of parsed.error.issues) {
-      if (schemaIssue.path[0] === "levenshtein" || refusesEmpty(match, schemaIssue)) {
-        continue;
-      }
-      issues.push(
-        issue("fib_match_invalid", at(...schemaIssue.path.map(String)), schemaIssue.message)
-      );
-    }
-  }
-  return issues;
-}
-function isLanguageTag(tag) {
-  try {
-    Intl.getCanonicalLocales(tag);
-    return true;
-  } catch {
-    return false;
-  }
-}
-function checkPairing(passage, blanks, ids) {
-  const issues = [];
-  const placeholders = /* @__PURE__ */ new Map();
-  for (const match of passage.matchAll(PLACEHOLDER_RE)) {
-    const id = match[1];
-    placeholders.set(id, (placeholders.get(id) ?? 0) + 1);
-  }
-  const blankIds = /* @__PURE__ */ new Map();
-  for (const id of ids) {
-    blankIds.set(id, (blankIds.get(id) ?? 0) + 1);
-  }
-  for (const [id, count] of blankIds) {
-    if (count > 1) {
-      issues.push(
-        issue("fib_blank_id_duplicate", ["passage"], `More than one blank has the id "${id}".`)
-      );
-    }
-  }
-  for (const [id, count] of placeholders) {
-    if (count > 1) {
-      issues.push(
-        issue(
-          "fib_placeholder_duplicate",
-          ["passage"],
-          `{{${id}}} appears more than once in the passage. Each blank goes in one place.`
-        )
-      );
-    }
-    if (!blankIds.has(id)) {
-      issues.push(
-        issue(
-          "fib_blank_missing",
-          ["passage"],
-          `The passage has {{${id}}}, but there is no blank with that id.`
-        )
-      );
-    }
-  }
-  for (const id of blankIds.keys()) {
-    if (!placeholders.has(id)) {
-      issues.push(
-        issue(
-          "fib_placeholder_missing",
-          ["passage"],
-          `Blank "${id}" is not in the passage. Put {{${id}}} where it goes.`
-        )
-      );
-    }
-  }
-  if (issues.length === 0 && !pairsOneToOne(placeholders, blanks)) {
-    issues.push(
-      issue(
-        "fib_blanks_mismatch",
-        ["passage"],
-        "The blanks and the {{id}} placeholders in the passage do not pair up one to one."
-      )
-    );
-  }
-  return issues;
-}
-function pairsOneToOne(placeholders, blanks) {
-  const blankIds = blanks.filter(isRecord).map((blank) => blank.id);
-  if (new Set(blankIds).size !== blankIds.length) {
-    return false;
-  }
-  if (placeholders.size !== blankIds.length) {
-    return false;
-  }
-  return blankIds.every((id) => typeof id === "string" && placeholders.get(id) === 1);
-}
-
-// src/authoring/gap-select.ts
-var MIN_CHOICES = 2;
-var gapSelectAuthoring = {
-  createDraft: ({ newId }) => ({
-    schemaVersion: "1.0",
-    type: "gap-select",
-    id: newId(),
-    title: "",
-    passage: "",
-    gaps: [],
-    scoringStrategy: "all-or-nothing"
-  }),
-  checkDraft: checkGapSelectDraft
-};
-function checkGapSelectDraft(draft) {
-  const issues = checkIdentity(draft, "gap-select");
-  const passage = draft.passage;
-  if (isUnwritten(passage)) {
-    issues.push(issue("gs_passage_required", ["passage"], "Write the passage."));
-  }
-  issues.push(...checkScoringStrategy(draft));
-  if (!isUnset(draft.presentation) && draft.presentation !== "dropdown") {
-    issues.push(
-      issue(
-        "gs_presentation_invalid",
-        ["presentation"],
-        'The only presentation is "dropdown". Leave it out unless you mean to set it.'
-      )
-    );
-  }
-  const banks = isUnset(draft.banks) ? [] : draft.banks;
-  const bankIds = /* @__PURE__ */ new Set();
-  if (Array.isArray(banks)) {
-    issues.push(...checkBanks(banks, bankIds));
-  }
-  const gaps = isUnset(draft.gaps) ? [] : draft.gaps;
-  const gapIds = [];
-  if (Array.isArray(gaps)) {
-    if (gaps.length === 0) {
-      issues.push(
-        issue(
-          "gs_gaps_required",
-          ["gaps"],
-          "Add at least one gap, and mark where it goes in the passage with {{id}}."
-        )
-      );
-    }
-    issues.push(...checkGaps(gaps, banks, bankIds, gapIds));
-    if (typeof passage === "string" && passage.trim() !== "") {
-      issues.push(...checkPairing2(passage, gaps, gapIds));
-    }
-  }
-  issues.push(...checkSharedOptional(draft));
-  return issues;
-}
-function checkBanks(banks, bankIds) {
-  const issues = [];
-  const repeated = /* @__PURE__ */ new Set();
-  for (const [index, bank] of banks.entries()) {
-    if (!isRecord(bank)) {
-      continue;
-    }
-    if (isMissingId(bank.id)) {
-      issues.push(
-        issue("gs_bank_id_required", ["banks", index, "id"], `Word bank ${index + 1} has no id.`)
-      );
-    } else if (typeof bank.id === "string") {
-      if (bankIds.has(bank.id)) {
-        repeated.add(bank.id);
-      }
-      bankIds.add(bank.id);
-    }
-    const name = typeof bank.id === "string" && bank.id !== "" ? `"${bank.id}"` : index + 1;
-    issues.push(...checkChoiceList(bank.choices, ["banks", index, "choices"], `word bank ${name}`));
-  }
-  for (const id of repeated) {
-    issues.push(
-      issue("gs_bank_id_duplicate", ["banks"], `More than one word bank has the id "${id}".`)
-    );
-  }
-  return issues;
-}
-function checkGaps(gaps, banks, bankIds, gapIds) {
-  const issues = [];
-  const atGaps = [];
-  const repeated = /* @__PURE__ */ new Set();
-  const seen = /* @__PURE__ */ new Set();
-  for (const [index, gap] of gaps.entries()) {
-    if (!isRecord(gap)) {
-      continue;
-    }
-    const ordinal = index + 1;
-    const name = typeof gap.id === "string" && gap.id !== "" ? `"${gap.id}"` : ordinal;
-    if (isMissingId(gap.id)) {
-      issues.push(issue("gs_gap_id_required", ["gaps", index, "id"], `Gap ${ordinal} has no id.`));
-    } else if (typeof gap.id === "string") {
-      if (seen.has(gap.id)) {
-        repeated.add(gap.id);
-      }
-      seen.add(gap.id);
-      gapIds.push(gap.id);
-    }
-    const hasOwn = !isUnset(gap.choices);
-    const hasBank = !isUnwritten(gap.bankId);
-    const bankBlank = typeof gap.bankId === "string" && gap.bankId.trim() === "";
-    if (bankBlank) {
-      issues.push(
-        issue(
-          "gs_choice_source_required",
-          ["gaps", index, "bankId"],
-          `Choose a word bank for gap ${name}, or remove the empty field.`
-        )
-      );
-    } else if (hasOwn && hasBank) {
-      atGaps.push(
-        issue(
-          "gs_choice_source_conflict",
-          ["gaps"],
-          `Gap ${name} has both its own choices and a word bank. Use one or the other.`
-        )
-      );
-    } else if (!hasOwn && !hasBank) {
-      atGaps.push(
-        issue(
-          "gs_choice_source_required",
-          ["gaps"],
-          `Give gap ${name} a list of choices, or point it at a word bank.`
-        )
-      );
-    }
-    if (hasBank && typeof gap.bankId === "string" && !bankIds.has(gap.bankId)) {
-      atGaps.push(
-        issue(
-          "gs_bank_unknown",
-          ["gaps"],
-          `Gap ${name} uses the word bank "${gap.bankId}", which does not exist.`
-        )
-      );
-    }
-    if (hasOwn) {
-      issues.push(...checkChoiceList(gap.choices, ["gaps", index, "choices"], `gap ${name}`));
-    }
-    issues.push(...checkAnswerKey(gap, index, name, banks, bankIds));
-  }
-  for (const id of repeated) {
-    atGaps.push(issue("gs_gap_id_duplicate", ["gaps"], `More than one gap has the id "${id}".`));
-  }
-  return [...issues, ...atGaps];
-}
-function checkAnswerKey(gap, index, name, banks, bankIds) {
-  const key = gap.correctChoiceId;
-  if (isUnwritten(key)) {
-    return [
-      issue(
-        "gs_correct_choice_required",
-        ["gaps", index, "correctChoiceId"],
-        `Mark the correct choice for gap ${name}.`
-      )
-    ];
-  }
-  if (typeof key !== "string") {
-    return [];
-  }
-  const choices = resolveChoices(gap, banks, bankIds);
-  if (choices === void 0) {
-    return [];
-  }
-  const offered = choices.some((choice) => isRecord(choice) && choice.id === key);
-  return offered ? [] : [
-    issue(
-      "gs_correct_choice_unknown",
-      ["gaps"],
-      `Gap ${name} is marked correct on "${key}", which is not one of its choices.`
-    )
-  ];
-}
-function resolveChoices(gap, banks, bankIds) {
-  const hasOwn = !isUnset(gap.choices);
-  const hasBank = !isUnwritten(gap.bankId);
-  if (hasOwn === hasBank) {
-    return void 0;
-  }
-  if (hasOwn) {
-    return Array.isArray(gap.choices) ? gap.choices : void 0;
-  }
-  if (typeof gap.bankId !== "string" || !bankIds.has(gap.bankId) || !Array.isArray(banks)) {
-    return void 0;
-  }
-  const bank = banks.find((entry) => isRecord(entry) && entry.id === gap.bankId);
-  return isRecord(bank) && Array.isArray(bank.choices) ? bank.choices : void 0;
-}
-function checkChoiceList(choices, path, owner) {
-  const issues = [];
-  const list = isUnset(choices) ? [] : choices;
-  if (!Array.isArray(list)) {
-    return issues;
-  }
-  if (list.length < MIN_CHOICES) {
-    issues.push(
-      issue(
-        "gs_choices_too_few",
-        path,
-        `Give ${owner} at least ${MIN_CHOICES} choices to pick from.`
-      )
-    );
-  }
-  const seen = /* @__PURE__ */ new Set();
-  const repeated = /* @__PURE__ */ new Set();
-  for (const [index, choice] of list.entries()) {
-    if (!isRecord(choice)) {
-      continue;
-    }
-    if (isMissingId(choice.id)) {
-      issues.push(
-        issue("gs_choice_id_required", [...path, index, "id"], `Choice ${index + 1} has no id.`)
-      );
-    } else if (typeof choice.id === "string") {
-      if (seen.has(choice.id)) {
-        repeated.add(choice.id);
-      }
-      seen.add(choice.id);
-    }
-    if (isUnwritten(choice.text)) {
-      issues.push(
-        issue(
-          "gs_choice_text_required",
-          [...path, index, "text"],
-          `Write the text of choice ${index + 1}.`
-        )
-      );
-    }
-  }
-  for (const id of repeated) {
-    issues.push(issue("gs_choice_id_duplicate", path, `More than one choice has the id "${id}".`));
-  }
-  return issues;
-}
-function checkPairing2(passage, gaps, gapIds) {
-  const issues = [];
-  const placeholders = /* @__PURE__ */ new Map();
-  for (const match of passage.matchAll(PLACEHOLDER_RE)) {
-    const id = match[1];
-    placeholders.set(id, (placeholders.get(id) ?? 0) + 1);
-  }
-  const ids = new Set(gapIds);
-  for (const [id, count] of placeholders) {
-    if (count > 1) {
-      issues.push(
-        issue(
-          "gs_placeholder_duplicate",
-          ["passage"],
-          `{{${id}}} appears more than once in the passage. Each gap goes in one place.`
-        )
-      );
-    }
-    if (!ids.has(id)) {
-      issues.push(
-        issue(
-          "gs_gap_missing",
-          ["passage"],
-          `The passage has {{${id}}}, but there is no gap with that id.`
-        )
-      );
-    }
-  }
-  for (const id of ids) {
-    if (!placeholders.has(id)) {
-      issues.push(
-        issue(
-          "gs_placeholder_missing",
-          ["passage"],
-          `Gap "${id}" is not in the passage. Put {{${id}}} where it goes.`
-        )
-      );
-    }
-  }
-  if (issues.length === 0 && !pairsOneToOne2(placeholders, gaps)) {
-    issues.push(
-      issue(
-        "gs_gaps_mismatch",
-        ["passage"],
-        "The gaps and the {{id}} placeholders in the passage do not pair up one to one."
-      )
-    );
-  }
-  return issues;
-}
-function pairsOneToOne2(placeholders, gaps) {
-  const ids = gaps.filter(isRecord).map((gap) => gap.id);
-  if (new Set(ids).size !== ids.length || placeholders.size !== ids.length) {
-    return false;
-  }
-  return ids.every((id) => typeof id === "string" && placeholders.get(id) === 1);
-}
-
-// src/authoring/multiple-choice.ts
-var MIN_OPTIONS = 2;
-var MAX_OPTIONS = 26;
-var multipleChoiceAuthoring = {
-  createDraft: ({ newId }) => ({
-    schemaVersion: "1.0",
-    type: "multiple-choice",
-    id: newId(),
-    title: "",
-    question: "",
-    mode: "single",
-    scoringStrategy: "all-or-nothing",
-    options: [
-      { id: newId(), text: "", isCorrect: false },
-      { id: newId(), text: "", isCorrect: false }
-    ]
-  }),
-  checkDraft: checkMultipleChoiceDraft
-};
-function checkMultipleChoiceDraft(draft) {
-  const issues = checkIdentity(draft, "multiple-choice");
-  if (isUnwritten(draft.question)) {
-    issues.push(issue("mc_question_required", ["question"], "Write the question."));
-  }
-  if (isUnwritten(draft.mode)) {
-    issues.push(
-      issue("mc_mode_required", ["mode"], "Choose whether learners select one option or several.")
-    );
-  }
-  issues.push(...checkScoringStrategy(draft));
-  const options = isUnset(draft.options) ? [] : draft.options;
-  if (Array.isArray(options)) {
-    if (options.length < MIN_OPTIONS) {
-      issues.push(issue("mc_options_too_few", ["options"], "Add at least two options."));
-    }
-    if (options.length > MAX_OPTIONS) {
-      issues.push(
-        issue("mc_options_too_many", ["options"], `Use no more than ${MAX_OPTIONS} options.`)
-      );
-    }
-    const seen = /* @__PURE__ */ new Set();
-    const repeated = /* @__PURE__ */ new Set();
-    let correct = 0;
-    for (const [index, option] of options.entries()) {
-      if (!isRecord(option)) {
-        continue;
-      }
-      const ordinal = index + 1;
-      if (isMissingId(option.id)) {
-        issues.push(
-          issue("mc_option_id_required", ["options", index, "id"], `Option ${ordinal} has no id.`)
-        );
-      } else if (typeof option.id === "string") {
-        if (seen.has(option.id)) {
-          repeated.add(option.id);
-        }
-        seen.add(option.id);
-      }
-      if (isUnwritten(option.text)) {
-        issues.push(
-          issue(
-            "mc_option_text_required",
-            ["options", index, "text"],
-            `Write the text of option ${ordinal}.`
-          )
-        );
-      }
-      if (isUnset(option.isCorrect)) {
-        issues.push(
-          issue(
-            "mc_option_correctness_required",
-            ["options", index, "isCorrect"],
-            `Say whether option ${ordinal} is correct.`
-          )
-        );
-      }
-      if (option.isCorrect === true) {
-        correct += 1;
-      }
-      if (isRecord(option.media)) {
-        issues.push(...checkOptionMedia(option.media, index, ordinal));
-      }
-    }
-    for (const id of repeated) {
-      issues.push(
-        issue("mc_option_id_duplicate", ["options"], `More than one option has the id "${id}".`)
-      );
-    }
-    if (correct === 0) {
-      issues.push(
-        issue(
-          "mc_correct_option_required",
-          ["options"],
-          draft.mode === "multi" ? "Mark at least one option as correct." : "Mark the correct option."
-        )
-      );
-    } else if (draft.mode === "single" && correct > 1) {
-      issues.push(
-        issue(
-          "mc_single_mode_one_correct",
-          ["options"],
-          "Only one option can be marked correct when learners select one option."
-        )
-      );
-    }
-  }
-  issues.push(...checkSharedOptional(draft));
-  return issues;
-}
-function checkOptionMedia(media, index, ordinal) {
-  const path = ["options", index, "media"];
-  const kind = media.type;
-  if (kind === "video" || kind === "embed") {
-    return [
-      issue(
-        "mc_option_media_kind",
-        [...path, "type"],
-        `Option ${ordinal} carries ${kind === "embed" ? "an embedded player" : "a video"}, which cannot be an option: its controls swallow the click that selects the answer. Use a picture or a recording.`
-      )
-    ];
-  }
-  return checkMedia(media, path, MultipleChoiceOptionMediaSchema);
-}
-
-// src/schemas/read-aloud.ts
-import { z as z8 } from "zod/v4";
-
-// src/scoring/speech/locale.ts
-var CANONICAL_LOCALE_RE = /^[a-z]{2,3}(?:-[A-Z][a-z]{3})?-(?:[A-Z]{2}|[0-9]{3})$/;
-
-// src/schemas/read-aloud.ts
-var READ_ALOUD_DIMENSIONS = ["accuracy", "fluency", "completeness", "prosody"];
-var READ_ALOUD_MAX_DIMENSIONS = READ_ALOUD_DIMENSIONS.length;
-var ReadAloudSlowMediaSchema = z8.strictObject({
-  type: z8.literal("audio"),
-  url: MediaUrlSchema,
-  alt: z8.string().min(1).optional()
-});
-var ReferenceTextSchema = z8.string().min(1).refine((text) => text.trim() !== "", {
-  error: "The text to read aloud must contain something to read."
-}).meta({ maxLength: READ_ALOUD_MAX_REFERENCE_LENGTH });
-var RecordingBoundsSchema = z8.looseObject({
-  maxSeconds: z8.number().gt(0).max(READ_ALOUD_MAX_SECONDS),
-  minSeconds: z8.number().min(0).optional(),
-  maxTakes: z8.number().int().min(1).max(READ_ALOUD_MAX_TAKES).optional()
-});
-var ReadAloudDimensionWeightSchema = z8.looseObject({
-  name: z8.enum(READ_ALOUD_DIMENSIONS),
-  weight: z8.number().min(0).max(READ_ALOUD_MAX_DIMENSION_WEIGHT)
-});
-var ReadAloudScoringSchema = z8.looseObject({
-  dimensions: z8.array(ReadAloudDimensionWeightSchema).min(1).max(READ_ALOUD_MAX_DIMENSIONS)
-});
-var ReadAloudDataShape = z8.looseObject({
-  schemaVersion: z8.literal("1.0"),
-  type: z8.literal("read-aloud"),
-  id: z8.string().min(1),
-  title: z8.string().min(1),
-  instructions: z8.string().optional(),
-  referenceText: ReferenceTextSchema,
-  locale: z8.string().regex(CANONICAL_LOCALE_RE, {
-    error: `The locale must be a BCP 47 tag in canonical form, with a region: "en-US", "es-419", "zh-Hant-TW". Pronunciation is assessed against one locale's speech, and "en" does not say whose.`
-  }),
-  media: MediaSchema.optional(),
-  slowMedia: ReadAloudSlowMediaSchema.optional(),
-  recording: RecordingBoundsSchema,
-  scoring: ReadAloudScoringSchema,
-  passThreshold: z8.number().min(0).max(1).optional(),
-  feedback: FeedbackSchema.optional(),
-  learningObjectives: z8.array(z8.string()).optional(),
-  difficultyLevel: z8.literal([1, 2, 3, 4, 5]).optional(),
-  ai: AiPermissionsSchema.optional()
-});
-var ReadAloudDataSchema = ReadAloudDataShape.check(
-  checkEvenAfterIssues((ctx) => {
-    if (ctx.issues.some((issue2) => (issue2.path?.length ?? 0) === 0)) {
-      return;
-    }
-    const { data, refused } = parsedFields(ctx);
-    const report = (path, input, message) => {
-      ctx.issues.push({ code: "custom", input, message, path: [...path] });
-    };
-    if (!refused.has("referenceText")) {
-      const text = data.referenceText;
-      const measured = dictationNormalizer(void 0).measure(text);
-      if (measured.tooLong) {
-        report(
-          ["referenceText"],
-          text,
-          `The text to read aloud is at most ${READ_ALOUD_MAX_REFERENCE_LENGTH} characters, before and after normalisation.`
-        );
-      }
-      if (measured.normalized === "") {
-        report(
-          ["referenceText"],
-          text,
-          "The text to read aloud must contain a word: after ignoring punctuation and spacing nothing is left, so no word would be marked and every reading would align as one insertion after another."
-        );
-      }
-      if (containsUnspacedScript(text)) {
-        report(
-          ["referenceText"],
-          text,
-          "A read-aloud item needs a script written with spaces between its words. The text is compared word by word, and a run of Han, kana, Thai, Lao, Khmer or Myanmar letters is one word however many it holds."
-        );
-      }
-    }
-    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 read-aloud model is read aloud: its recording must be audio."
-      );
-    }
-    if (mediaParses && slowParses && data.slowMedia !== void 0) {
-      if (data.media === void 0) {
-        report(
-          ["media"],
-          data.media,
-          "A slow model recording accompanies a recording: add `media` first."
-        );
-      }
-      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`."
-        );
-      }
-      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 model recording must be a different file from the recording."
-        );
-      }
-    }
-    if (!refused.has("scoring")) {
-      const dimensions = data.scoring.dimensions;
-      const seen = /* @__PURE__ */ new Set();
-      for (const [index, dimension] of dimensions.entries()) {
-        if (seen.has(dimension.name)) {
-          report(
-            ["scoring", "dimensions", index, "name"],
-            dimension.name,
-            `"${dimension.name}" is already weighed: a dimension counted twice hides which weight the grade used.`
-          );
-        }
-        seen.add(dimension.name);
-      }
-      if (dimensions.every((dimension) => dimension.weight === 0)) {
-        report(
-          ["scoring", "dimensions"],
-          dimensions,
-          "At least one dimension must carry a weight above 0: with every weight at 0 there is no weighted total, and every take would be unscorable."
-        );
-      }
-    }
-    if (!refused.has("recording")) {
-      const { minSeconds, maxSeconds } = data.recording;
-      if (minSeconds !== void 0 && minSeconds >= maxSeconds) {
-        report(
-          ["recording", "minSeconds"],
-          minSeconds,
-          "The shortest take must be shorter than the longest."
-        );
-      }
-    }
-  })
-);
-
-// src/authoring/read-aloud.ts
-var readAloudAuthoring = {
-  createDraft: ({ newId }) => ({
-    schemaVersion: "1.0",
-    type: "read-aloud",
-    id: newId(),
-    title: "",
-    referenceText: "",
-    locale: "",
-    recording: { maxSeconds: 0 },
-    scoring: { dimensions: [] }
-  }),
-  checkDraft: checkReadAloudDraft
-};
-function checkReadAloudDraft(draft) {
-  const issues = checkIdentity(draft, "read-aloud");
-  issues.push(...checkReferenceText(draft.referenceText));
-  issues.push(...checkLocale(draft.locale));
-  issues.push(...checkRecording2(draft.recording));
-  issues.push(...checkDimensions(draft.scoring));
-  issues.push(...checkModelRecording(draft.media));
-  issues.push(...checkSlowRecording2(draft));
-  issues.push(...checkSharedOptional(draft));
-  return issues;
-}
-function checkReferenceText(referenceText) {
-  if (isUnwritten(referenceText)) {
-    return [
-      issue("ra_reference_text_required", ["referenceText"], "Write the text to be read aloud.")
-    ];
-  }
-  if (typeof referenceText !== "string") {
-    return [];
-  }
-  const issues = [];
-  const measured = dictationNormalizer(void 0).measure(referenceText);
-  if (measured.tooLong) {
-    issues.push(
-      issue(
-        "ra_reference_text_too_long",
-        ["referenceText"],
-        `The text is longer than ${READ_ALOUD_MAX_REFERENCE_LENGTH} characters, before or after normalisation. A read-aloud item is a sentence or a short paragraph.`
-      )
-    );
-  }
-  if (measured.normalized === "") {
-    issues.push(
-      issue(
-        "ra_reference_text_unreadable",
-        ["referenceText"],
-        "The text has no word to read: once punctuation and spacing are ignored, nothing is left. A reading of it would be marked against no word at all."
-      )
-    );
-  }
-  if (containsUnspacedScript(referenceText)) {
-    issues.push(
-      issue(
-        "ra_reference_text_unspaced_script",
-        ["referenceText"],
-        "The text is written in a script that does not separate its words with spaces. Each word is marked on its own, and a run of Han, kana, Thai, Lao, Khmer or Myanmar letters would be marked as one word."
-      )
-    );
-  }
-  return issues;
-}
-function checkLocale(locale) {
-  if (isUnwritten(locale)) {
-    return [
-      issue(
-        "ra_locale_required",
-        ["locale"],
-        'Choose the language the learner reads in, with its region \u2014 "en-US", not "en".'
-      )
-    ];
-  }
-  if (typeof locale !== "string" || CANONICAL_LOCALE_RE.test(locale)) {
-    return [];
-  }
-  return [
-    issue(
-      "ra_locale_invalid",
-      ["locale"],
-      `The language must be a BCP 47 tag in canonical form, with a region: "en-US", "es-419", "zh-Hant-TW". Pronunciation is assessed against one locale's speech.`
-    )
-  ];
-}
-function checkRecording2(recording) {
-  if (isUnset(recording)) {
-    return [maxSecondsRequired()];
-  }
-  if (!isRecord(recording)) {
-    return [];
-  }
-  const issues = [];
-  const max = recording.maxSeconds;
-  if (isUnset(max) || max === 0) {
-    issues.push(maxSecondsRequired());
-  } else if (typeof max === "number" && !(Number.isFinite(max) && max > 0 && max <= READ_ALOUD_MAX_SECONDS)) {
-    issues.push(
-      issue(
-        "ra_max_seconds_out_of_range",
-        ["recording", "maxSeconds"],
-        `A take is at most ${READ_ALOUD_MAX_SECONDS} seconds long.`
-      )
-    );
-  }
-  const min = recording.minSeconds;
-  if (typeof min === "number" && !(Number.isFinite(min) && min >= 0)) {
-    issues.push(minSecondsOutOfRange("The shortest take is a number of seconds, 0 or more."));
-  } else if (typeof min === "number" && typeof max === "number" && max > 0 && min >= max) {
-    issues.push(minSecondsOutOfRange("The shortest take must be shorter than the longest."));
-  }
-  const takes = recording.maxTakes;
-  if (typeof takes === "number" && !(isWholeNumber(takes) && takes >= 1 && takes <= READ_ALOUD_MAX_TAKES)) {
-    issues.push(
-      issue(
-        "ra_max_takes_out_of_range",
-        ["recording", "maxTakes"],
-        `How many takes a learner may record is a whole number from 1 to ${READ_ALOUD_MAX_TAKES}.`
-      )
-    );
-  }
-  return issues;
-}
-function maxSecondsRequired() {
-  return issue(
-    "ra_max_seconds_required",
-    ["recording", "maxSeconds"],
-    "Set how long a take may be, in seconds."
-  );
-}
-function minSecondsOutOfRange(message) {
-  return issue("ra_min_seconds_out_of_range", ["recording", "minSeconds"], message);
-}
-var DIMENSION_NAMES = READ_ALOUD_DIMENSIONS;
-function checkDimensions(scoring) {
-  if (isUnset(scoring)) {
-    return [dimensionsRequired()];
-  }
-  if (!isRecord(scoring)) {
-    return [];
-  }
-  const dimensions = scoring.dimensions;
-  if (isUnset(dimensions)) {
-    return [dimensionsRequired()];
-  }
-  if (!Array.isArray(dimensions)) {
-    return [];
-  }
-  if (dimensions.length === 0) {
-    return [dimensionsRequired()];
-  }
-  const issues = [];
-  const seen = /* @__PURE__ */ new Set();
-  let everyWeightUsable = true;
-  let totalWeight = 0;
-  for (const [index, dimension] of dimensions.entries()) {
-    if (!isRecord(dimension)) {
-      everyWeightUsable = false;
-      continue;
-    }
-    const path = ["scoring", "dimensions", index];
-    const name = dimension.name;
-    if (!DIMENSION_NAMES.includes(name)) {
-      issues.push(
-        issue(
-          "ra_dimension_name_invalid",
-          [...path, "name"],
-          `Choose what dimension ${index + 1} measures: ${READ_ALOUD_DIMENSIONS.join(", ")}.`
-        )
-      );
-    } else if (seen.has(name)) {
-      issues.push(
-        issue(
-          "ra_dimension_duplicate",
-          [...path, "name"],
-          `"${String(name)}" is already weighed. Remove this one, or measure something else.`
-        )
-      );
-    } else {
-      seen.add(name);
-    }
-    const weight = dimension.weight;
-    if (typeof weight === "number" && Number.isFinite(weight) && weight >= 0 && weight <= READ_ALOUD_MAX_DIMENSION_WEIGHT) {
-      totalWeight += weight;
-    } else {
-      everyWeightUsable = false;
-      issues.push(
-        issue(
-          "ra_dimension_weight_invalid",
-          [...path, "weight"],
-          `Give dimension ${index + 1} a weight: a number from 0 to ${READ_ALOUD_MAX_DIMENSION_WEIGHT}.`
-        )
-      );
-    }
-  }
-  if (everyWeightUsable && totalWeight === 0) {
-    issues.push(
-      issue(
-        "ra_dimension_weights_zero",
-        ["scoring", "dimensions"],
-        "Give at least one dimension a weight above 0. With every weight at 0 there is no weighted total, and every take would be unscorable."
-      )
-    );
-  }
-  return issues;
-}
-function dimensionsRequired() {
-  return issue(
-    "ra_dimensions_required",
-    ["scoring", "dimensions"],
-    "Choose what the grade measures: at least one of accuracy, fluency, completeness or prosody, with a weight."
-  );
-}
-function checkModelRecording(media) {
-  if (!isRecord(media)) {
-    return [];
-  }
-  const kind = media.type;
-  return isUnwritten(kind) || kind === "audio" ? [] : [
-    issue(
-      "ra_media_kind",
-      ["media", "type"],
-      "A read-aloud model is read aloud: its recording must be audio."
-    )
-  ];
-}
-function checkSlowRecording2(draft) {
-  const slow = draft.slowMedia;
-  if (!isRecord(slow)) {
-    return [];
-  }
-  const kind = slow.type;
-  const wrongKind = !isUnwritten(kind) && kind !== "audio";
-  const issues = wrongKind ? [issue("media_invalid", ["slowMedia", "type"], "The slow model recording must be audio.")] : [];
-  issues.push(
-    ...checkMedia(
-      wrongKind ? { ...slow, type: "audio" } : slow,
-      ["slowMedia"],
-      ReadAloudSlowMediaSchema
-    )
-  );
-  const media = draft.media;
-  if (isUnset(media)) {
-    issues.push(
-      issue(
-        "ra_slow_media_without_media",
-        ["media"],
-        "A slow model 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(
-        "ra_slow_media_beside_play_limit",
-        ["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(
-        "ra_slow_media_same_recording",
-        ["slowMedia", "url"],
-        "The slow model recording is the same file as the recording. Point it at the slower reading."
-      )
-    );
-  }
-  return issues;
-}
-
-// src/authoring/written-response.ts
-var writtenResponseAuthoring = {
-  createDraft: ({ newId }) => ({
-    schemaVersion: "1.0",
-    type: "written-response",
-    id: newId(),
-    title: "",
-    prompt: "",
-    minWords: 0,
-    maxWords: 0
-  }),
-  checkDraft: checkWrittenResponseDraft
-};
-function checkWrittenResponseDraft(draft) {
-  const issues = checkIdentity(draft, "written-response");
-  if (isUnwritten(draft.prompt)) {
-    issues.push(
-      issue(
-        "wr_prompt_required",
-        ["prompt"],
-        isUnwritten(draft.promptHtml) ? "Write the prompt." : "Write the prompt as plain text too. The rich-text prompt is shown only where a sanitiser is supplied; the plain text is shown everywhere else."
-      )
-    );
-  }
-  const min = draft.minWords;
-  const max = draft.maxWords;
-  if (isUnset(min)) {
-    issues.push(
-      issue(
-        "wr_min_words_required",
-        ["minWords"],
-        "Set the minimum number of words. Use 0 for no minimum."
-      )
-    );
-  } else if (!(isWholeNumber(min) && min >= 0)) {
-    issues.push(
-      issue(
-        "wr_min_words_invalid",
-        ["minWords"],
-        isTooLarge(min) ? "The minimum word count is too large." : "The minimum word count must be a whole number, 0 or more."
-      )
-    );
-  }
-  if (isUnset(max) || max === 0) {
-    issues.push(issue("wr_max_words_required", ["maxWords"], "Set the maximum number of words."));
-  } else if (!(isWholeNumber(max) && max >= 1)) {
-    issues.push(
-      issue(
-        "wr_max_words_invalid",
-        ["maxWords"],
-        isTooLarge(max) ? "The maximum word count is too large." : "The maximum word count must be a whole number, 1 or more."
-      )
-    );
-  } else if (typeof min === "number" && max < min) {
-    issues.push(
-      issue(
-        "wr_word_bounds_order",
-        ["maxWords"],
-        "The maximum word count cannot be lower than the minimum."
-      )
-    );
-  }
-  const rubric = draft.rubric;
-  if (isRecord(rubric)) {
-    const criteria = isUnset(rubric.criteria) ? [] : rubric.criteria;
-    if (Array.isArray(criteria)) {
-      issues.push(...checkCriteria(criteria));
-    }
-  }
-  issues.push(...checkSharedOptional(draft));
-  return issues;
-}
-function checkCriteria(criteria) {
-  const issues = [];
-  if (criteria.length === 0) {
-    issues.push(
-      issue(
-        "wr_rubric_criteria_required",
-        ["rubric", "criteria"],
-        "Add at least one rubric criterion, or remove the rubric."
-      )
-    );
-    return issues;
-  }
-  let totalWeight = 0;
-  let everyWeightUsable = true;
-  for (const [index, criterion] of criteria.entries()) {
-    if (!isRecord(criterion)) {
-      everyWeightUsable = false;
-      continue;
-    }
-    const ordinal = index + 1;
-    const path = ["rubric", "criteria", index];
-    if (isUnwritten(criterion.name)) {
-      issues.push(
-        issue("wr_criterion_name_required", [...path, "name"], `Name rubric criterion ${ordinal}.`)
-      );
-    }
-    const weight = criterion.weight;
-    if (isUnset(weight)) {
-      everyWeightUsable = false;
-      issues.push(
-        issue(
-          "wr_criterion_weight_required",
-          [...path, "weight"],
-          `Give rubric criterion ${ordinal} a weight.`
-        )
-      );
-    } else if (!(typeof weight === "number" && Number.isFinite(weight) && weight >= 0)) {
-      everyWeightUsable = false;
-      issues.push(
-        issue(
-          "wr_criterion_weight_invalid",
-          [...path, "weight"],
-          "A rubric weight must be a number, 0 or more."
-        )
-      );
-    } else {
-      totalWeight += weight;
-    }
-  }
-  if (everyWeightUsable && totalWeight === 0) {
-    issues.push(
-      issue(
-        "wr_rubric_weights_zero",
-        ["rubric", "criteria"],
-        "Give at least one rubric criterion a weight above 0. With every weight at 0, no weighted total can be computed."
-      )
-    );
-  } else if (totalWeight === Number.POSITIVE_INFINITY) {
-    issues.push(
-      issue(
-        "wr_rubric_weights_too_large",
-        ["rubric", "criteria"],
-        "The rubric weights add up to more than can be calculated with. Use smaller weights."
-      )
-    );
-  }
-  return issues;
-}
-
-// src/schemas/gap-select.ts
-import { z as z9 } from "zod/v4";
-var GapSelectChoiceSchema = z9.looseObject({
-  id: z9.string().min(1),
-  text: z9.string().min(1)
-});
-var GapSelectBankSchema = z9.looseObject({
-  id: z9.string().min(1),
-  choices: z9.array(GapSelectChoiceSchema).min(2)
-});
-var GapSelectGapSchema = z9.looseObject({
-  id: z9.string().min(1),
-  choices: z9.array(GapSelectChoiceSchema).min(2).optional(),
-  bankId: z9.string().min(1).optional(),
-  correctChoiceId: z9.string().min(1),
-  feedback: z9.string().optional()
-});
-function resolveChoices2(gap, banks) {
-  if (gap.choices !== void 0) {
-    return gap.bankId === void 0 ? gap.choices : void 0;
-  }
-  if (gap.bankId === void 0) {
-    return void 0;
-  }
-  return banks.find((bank) => bank.id === gap.bankId)?.choices;
-}
-function placeholderCounts(passage) {
-  const counts = /* @__PURE__ */ new Map();
-  for (const match of passage.matchAll(PLACEHOLDER_RE)) {
-    const id = match[1];
-    counts.set(id, (counts.get(id) ?? 0) + 1);
-  }
-  return counts;
-}
-var GapSelectDataSchema = z9.looseObject({
-  schemaVersion: z9.literal("1.0"),
-  type: z9.literal("gap-select"),
-  id: z9.string().min(1),
-  title: z9.string().min(1),
-  passage: z9.string().min(1),
-  passageHtml: z9.string().optional(),
-  gaps: z9.array(GapSelectGapSchema).min(1),
-  banks: z9.array(GapSelectBankSchema).optional(),
-  scoringStrategy: z9.enum(["all-or-nothing", "partial"]),
-  presentation: z9.literal("dropdown").optional(),
-  shuffleChoices: z9.boolean().optional(),
-  media: MediaSchema.optional(),
-  feedback: FeedbackSchema.optional(),
-  passThreshold: z9.number().min(0).max(1).optional(),
-  locale: z9.string().optional(),
-  learningObjectives: z9.array(z9.string()).optional(),
-  difficultyLevel: z9.literal([1, 2, 3, 4, 5]).optional(),
-  ai: AiPermissionsSchema.optional()
-}).refine(
-  (data) => {
-    const ids = (data.banks ?? []).map((bank) => bank.id);
-    return new Set(ids).size === ids.length;
-  },
-  { error: "Word bank ids must be unique.", path: ["banks"] }
-).refine(
-  (data) => {
-    const ids = data.gaps.map((gap) => gap.id);
-    return new Set(ids).size === ids.length;
-  },
-  { error: "Gap ids must be unique.", path: ["gaps"] }
-).refine(
-  (data) => {
-    const counts = placeholderCounts(data.passage);
-    const ids = data.gaps.map((gap) => gap.id);
-    return counts.size === new Set(ids).size && ids.every((id) => counts.get(id) === 1) && [...counts.values()].every((count) => count === 1);
-  },
-  {
-    error: "Every gap must appear exactly once in the passage as {{gap_id}}, and every {{gap_id}} must have a gap.",
-    path: ["passage"]
-  }
-).refine(
-  (data) => data.gaps.every((gap) => gap.choices === void 0 !== (gap.bankId === void 0)),
-  {
-    error: "Each gap needs exactly one choice source: its own `choices`, or a `bankId`.",
-    path: ["gaps"]
-  }
-).refine(
-  (data) => {
-    const bankIds = new Set((data.banks ?? []).map((bank) => bank.id));
-    return data.gaps.every((gap) => gap.bankId === void 0 || bankIds.has(gap.bankId));
-  },
-  { error: "A gap references a `bankId` that no word bank defines.", path: ["gaps"] }
-).refine(
-  (data) => {
-    const banks = data.banks ?? [];
-    return data.gaps.every((gap) => {
-      const choices = resolveChoices2(gap, banks);
-      if (choices === void 0) {
-        return true;
-      }
-      const ids = choices.map((choice) => choice.id);
-      return new Set(ids).size === ids.length && ids.includes(gap.correctChoiceId);
-    });
-  },
-  {
-    error: "Each gap needs unique choice ids and a `correctChoiceId` that is one of the choices it offers.",
-    path: ["gaps"]
-  }
-);
-
-// src/schemas/redacted.ts
-import { z as z11 } from "zod/v4";
-
-// src/schemas/written-response.ts
-import { z as z10 } from "zod/v4";
-var WrittenResponseRubricCriterionSchema = z10.looseObject({
-  name: z10.string().min(1),
-  description: z10.string().optional(),
-  weight: z10.number().min(0)
-});
-var WrittenResponseRubricSchema = z10.looseObject({
-  label: z10.string().optional(),
-  criteria: z10.array(WrittenResponseRubricCriterionSchema).min(1)
-});
-var RedactedWrittenResponseRubricCriterionSchema = z10.strictObject({
-  name: z10.string().min(1),
-  description: z10.string().optional(),
-  weight: z10.number().min(0)
-});
-var RedactedWrittenResponseRubricSchema = z10.strictObject({
-  label: z10.string().optional(),
-  criteria: z10.array(RedactedWrittenResponseRubricCriterionSchema).min(1)
-});
-var WrittenResponseDataSchema = z10.looseObject({
-  schemaVersion: z10.literal("1.0"),
-  type: z10.literal("written-response"),
-  id: z10.string().min(1),
-  title: z10.string().min(1),
-  prompt: z10.string(),
-  promptHtml: z10.string().optional(),
-  minWords: z10.number().int().min(0),
-  maxWords: z10.number().int().min(1),
-  rubric: WrittenResponseRubricSchema.optional(),
-  languageTarget: z10.string().optional(),
-  media: MediaSchema.optional(),
-  feedback: FeedbackSchema.optional(),
-  passThreshold: z10.number().min(0).max(1).optional(),
-  locale: z10.string().optional(),
-  learningObjectives: z10.array(z10.string()).optional(),
-  difficultyLevel: z10.literal([1, 2, 3, 4, 5]).optional(),
-  ai: AiPermissionsSchema.optional()
-}).refine((data) => data.maxWords >= data.minWords, {
-  error: "maxWords must be greater than or equal to minWords.",
-  path: ["maxWords"]
-});
-
-// src/schemas/redacted.ts
-var redactedBase = {
-  /** Marker distinguishing a redacted projection from full activity data. */
-  redacted: z11.literal(true),
-  /** Slot identity, carried through redaction so the client and the plan agree. */
-  slotKey: z11.string().min(1).optional(),
-  schemaVersion: z11.literal("1.0"),
-  id: z11.string().min(1),
-  title: z11.string().min(1),
-  media: RedactedMediaSchema.optional(),
-  passThreshold: z11.number().min(0).max(1).optional(),
-  locale: z11.string().optional(),
-  learningObjectives: z11.array(z11.string()).optional(),
-  difficultyLevel: z11.literal([1, 2, 3, 4, 5]).optional(),
-  ai: z11.strictObject({ explanations: z11.boolean().optional(), hints: z11.boolean().optional() }).optional()
-};
-var RedactedMultipleChoiceOptionMediaSchema = z11.strictObject({
-  type: z11.enum(["image", "audio"]),
-  url: z11.string().min(1),
-  alt: z11.string().min(1).optional(),
-  captionsUrl: z11.string().min(1).optional()
-});
-var RedactedMultipleChoiceOptionSchema = z11.strictObject({
-  id: z11.string().min(1),
-  text: z11.string().min(1),
-  media: RedactedMultipleChoiceOptionMediaSchema.optional()
-});
-var RedactedMultipleChoiceDataSchema = z11.strictObject({
-  ...redactedBase,
-  type: z11.literal("multiple-choice"),
-  question: z11.string().min(1),
-  questionHtml: z11.string().optional(),
-  mode: z11.enum(["single", "multi"]),
-  options: z11.array(RedactedMultipleChoiceOptionSchema).min(2).max(26),
-  shuffle: z11.boolean().optional()
-});
-var RedactedBlankConfigSchema = z11.strictObject({
-  id: z11.string().min(1),
-  hint: z11.string().optional()
-});
-var RedactedFillInTheBlanksDataSchema = z11.strictObject({
-  ...redactedBase,
-  type: z11.literal("fill-in-the-blanks"),
-  passage: z11.string().min(1),
-  passageHtml: z11.string().optional(),
-  blanks: z11.array(RedactedBlankConfigSchema).min(1)
-});
-var RedactedGapSelectChoiceSchema = z11.strictObject({
-  id: z11.string().min(1),
-  text: z11.string().min(1)
-});
-var RedactedGapSelectBankSchema = z11.strictObject({
-  id: z11.string().min(1),
-  choices: z11.array(RedactedGapSelectChoiceSchema).min(2)
-});
-var RedactedGapSelectGapSchema = z11.strictObject({
-  id: z11.string().min(1),
-  choices: z11.array(RedactedGapSelectChoiceSchema).min(2).optional(),
-  bankId: z11.string().min(1).optional()
-});
-var RedactedGapSelectDataSchema = z11.strictObject({
-  ...redactedBase,
-  type: z11.literal("gap-select"),
-  passage: z11.string().min(1),
-  passageHtml: z11.string().optional(),
-  gaps: z11.array(RedactedGapSelectGapSchema).min(1),
-  banks: z11.array(RedactedGapSelectBankSchema).optional(),
-  presentation: z11.literal("dropdown").optional(),
-  shuffleChoices: z11.boolean().optional()
-});
-var RedactedWrittenResponseDataSchema = z11.strictObject({
-  ...redactedBase,
-  type: z11.literal("written-response"),
-  prompt: z11.string(),
-  promptHtml: z11.string().optional(),
-  minWords: z11.number().int().min(0),
-  maxWords: z11.number().int().min(1),
-  rubric: RedactedWrittenResponseRubricSchema.optional(),
-  languageTarget: z11.string().optional()
-});
-var RedactedDictationSlowMediaSchema = z11.strictObject({
-  type: z11.literal("audio"),
-  url: MediaUrlSchema,
-  alt: z11.string().min(1).optional()
-});
-var RedactedDictationDataSchema = z11.strictObject({
-  ...redactedBase,
-  type: z11.literal("dictation"),
-  slowMedia: RedactedDictationSlowMediaSchema.optional(),
-  hints: z11.strictObject({ mode: z11.literal("progressive-words") }).optional()
-}).check((ctx) => {
-  const data = ctx.value;
-  for (const captions of captionFieldsOf(data.media)) {
-    ctx.issues.push({
-      code: "custom",
-      input: data.media?.[captions],
-      message: "A dictation recording cannot carry captions: the captions are the answer, so this payload is not learner-safe.",
-      path: ["media", captions]
-    });
-  }
-  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"]
-    });
-  }
-});
-var RedactedReadAloudDataSchema = z11.strictObject({
-  ...redactedBase,
-  type: z11.literal("read-aloud"),
-  locale: z11.string().regex(CANONICAL_LOCALE_RE),
-  instructions: z11.string().optional(),
-  referenceText: z11.string().min(1),
-  slowMedia: ReadAloudSlowMediaSchema.optional(),
-  recording: z11.strictObject({
-    maxSeconds: z11.number().gt(0).max(READ_ALOUD_MAX_SECONDS),
-    minSeconds: z11.number().min(0).optional(),
-    maxTakes: z11.number().int().min(1).max(READ_ALOUD_MAX_TAKES).optional()
-  }),
-  scoring: z11.strictObject({
-    dimensions: z11.array(
-      z11.strictObject({
-        name: z11.enum(READ_ALOUD_DIMENSIONS),
-        weight: z11.number().min(0).max(READ_ALOUD_MAX_DIMENSION_WEIGHT)
-      })
-    ).min(1).max(READ_ALOUD_DIMENSIONS.length)
-  })
-}).check((ctx) => {
-  const data = ctx.value;
-  if (data.media !== void 0 && data.media.type !== "audio") {
-    ctx.issues.push({
-      code: "custom",
-      input: data.media.type,
-      message: "A read-aloud model recording must be audio, so this payload is not renderable.",
-      path: ["media", "type"]
-    });
-  }
-  if (data.slowMedia !== void 0 && data.media === void 0) {
-    ctx.issues.push({
-      code: "custom",
-      input: data.slowMedia,
-      message: "A slow model recording accompanies a recording: this payload has no `media`.",
-      path: ["media"]
-    });
-  }
-  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.slowMedia.url === data.media?.url) {
-    ctx.issues.push({
-      code: "custom",
-      input: data.slowMedia.url,
-      message: "The slow model recording must be a different file from the recording.",
-      path: ["slowMedia", "url"]
-    });
-  }
-});
-
-// 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,
-      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;
-}
-
-// src/scoring/strategies/partial.ts
-function partialStrategy(correctSelected, incorrectSelected, totalCorrect, totalIncorrect) {
-  const reward = correctSelected / totalCorrect;
-  const penalty = totalIncorrect === 0 ? 0 : incorrectSelected / totalIncorrect;
-  return Math.max(0, reward - penalty);
-}
-function partialBlankStrategy(correctBlanks, totalBlanks) {
-  return correctBlanks / totalBlanks;
-}
-
-// src/scoring/activity-scorers/fill-in-the-blanks.ts
-function policyFor(blank) {
-  return {
-    ...blank.caseSensitive !== void 0 ? { caseSensitive: blank.caseSensitive } : {},
-    ...blank.trimWhitespace !== void 0 ? { trim: blank.trimWhitespace } : {},
-    ...blank.match
-  };
-}
-function scoreFillInTheBlanks(data, response) {
-  const details = [];
-  const perBlankCorrect = [];
-  for (const blank of data.blanks) {
-    const rawInput = response.answers[blank.id];
-    const input = typeof rawInput === "string" ? rawInput : "";
-    const matched = matchText(input, blank.acceptedAnswers, policyFor(blank)).matched;
-    perBlankCorrect.push(matched);
-    details.push({
-      itemId: blank.id,
-      outcome: matched ? "correct" : "incorrect",
-      learnerResponse: [input],
-      correctResponse: [...blank.acceptedAnswers],
-      weight: 1
-    });
-  }
-  const correctBlanks = perBlankCorrect.filter(Boolean).length;
-  const scoreValue = data.scoringStrategy === "all-or-nothing" ? allOrNothingStrategy(perBlankCorrect) : partialBlankStrategy(correctBlanks, data.blanks.length);
-  return { score: scoreValue, maxScore: 1, feedback: null, details };
-}
-
-// src/scoring/activity-scorers/gap-select.ts
-function choicesFor(data, gap) {
-  if (gap.choices !== void 0) {
-    return gap.choices;
-  }
-  return data.banks?.find((bank) => bank.id === gap.bankId)?.choices ?? [];
-}
-function scoreGapSelect(data, response) {
-  const details = [];
-  const perGapCorrect = [];
-  for (const gap of data.gaps) {
-    const raw = response.selections[gap.id];
-    const selected = typeof raw === "string" ? raw : "";
-    const choices = choicesFor(data, gap);
-    const offered = choices.some((choice) => choice.id === selected);
-    const answered = selected !== "" && offered;
-    const correct = answered && selected === gap.correctChoiceId;
-    perGapCorrect.push(correct);
-    details.push({
-      itemId: gap.id,
-      outcome: correct ? "correct" : answered ? "incorrect" : "incorrect-omission",
-      learnerResponse: [selected],
-      correctResponse: [gap.correctChoiceId],
-      weight: 1
-    });
-  }
-  const correctGaps = perGapCorrect.filter(Boolean).length;
-  const scoreValue = data.scoringStrategy === "all-or-nothing" ? allOrNothingStrategy(perGapCorrect) : partialBlankStrategy(correctGaps, data.gaps.length);
-  return { score: scoreValue, maxScore: 1, feedback: null, details };
-}
-
-// src/scoring/activity-scorers/multiple-choice.ts
-function scoreMultipleChoice(data, response) {
-  const optionById = new Map(data.options.map((option) => [option.id, option]));
-  const selected = new Set(response.selectedOptionIds);
-  const totalCorrect = data.options.filter((option) => option.isCorrect).length;
-  const totalIncorrect = data.options.length - totalCorrect;
-  let scoreValue;
-  if (data.scoringStrategy === "all-or-nothing") {
-    if (data.mode === "single") {
-      scoreValue = response.selectedOptionIds.length === 1 && optionById.get(response.selectedOptionIds[0])?.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));
-      scoreValue = selected.size === correctIds.length && allCorrectSelected ? 1 : 0;
-    }
-  } else {
-    let correctSelected = 0;
-    let incorrectSelected = 0;
-    for (const id of selected) {
-      const option = optionById.get(id);
-      if (option?.isCorrect) {
-        correctSelected += 1;
-      } else {
-        incorrectSelected += 1;
-      }
-    }
-    scoreValue = partialStrategy(correctSelected, incorrectSelected, totalCorrect, totalIncorrect);
-  }
-  const details = data.options.map((option) => {
-    const wasSelected = selected.has(option.id);
-    const outcome = wasSelected ? option.isCorrect ? "correct" : "incorrect" : option.isCorrect ? "incorrect-omission" : "correct-omission";
-    return {
-      itemId: option.id,
-      outcome,
-      learnerResponse: [wasSelected ? "selected" : "not-selected"],
-      correctResponse: [option.isCorrect ? "selected" : "not-selected"],
-      weight: 1
-    };
-  });
-  return { score: scoreValue, maxScore: 1, feedback: null, details };
-}
-
-// src/registry/builtins.ts
-var MEDIA_FIELD_POLICY = {
-  type: "public",
-  url: "public",
-  alt: "public",
-  captionsUrl: "public",
-  poster: "public",
-  // Applies to every element of the array.
-  tracks: {
-    kind: "public",
-    src: "public",
-    srclang: "public",
-    label: "public",
-    default: "public"
-  },
-  playback: {
-    controls: "public",
-    maxPlays: "public",
-    seek: "public",
-    rate: "public",
-    nativeControlHints: "public"
-  }
-};
-var SHARED_PUBLIC_FIELDS = {
-  schemaVersion: "public",
-  type: "public",
-  id: "public",
-  // Assembly metadata, not content: it names the slot this item occupies in a
-  // paper. It has to survive redaction, or the exam client derives positional
-  // slot ids while the server's stored plan holds keyed ones, and the
-  // responses cannot be matched back to the attempt.
-  slotKey: "public",
-  title: "public",
-  media: MEDIA_FIELD_POLICY,
-  passThreshold: "public",
-  locale: "public",
-  learningObjectives: "public",
-  difficultyLevel: "public",
-  // What an author allows AI to do for the item. Public, field by field: a
-  // review that explains an answer must still honour an author who said no,
-  // and an unclassified key parked inside it must not ride along.
-  ai: { explanations: "public", hints: "public" }
-};
-var FEEDBACK_FIELD_POLICY = {
-  correct: "answer-key",
-  incorrect: "answer-key"
-};
-var TEXT_MATCH_FIELD_POLICY = {
-  caseSensitive: "answer-key",
-  trim: "answer-key",
-  normalize: "answer-key",
-  foldDiacritics: "answer-key",
-  collapseInnerWhitespace: "answer-key",
-  ignorePunctuation: "answer-key",
-  levenshtein: "answer-key",
-  locale: "answer-key"
-};
-var MULTIPLE_CHOICE_FIELD_POLICY = {
-  ...SHARED_PUBLIC_FIELDS,
-  question: "public",
-  questionHtml: "public",
-  mode: "public",
-  shuffle: "public",
-  scoringStrategy: "answer-key",
-  feedback: FEEDBACK_FIELD_POLICY,
-  options: {
-    id: "public",
-    text: "public",
-    isCorrect: "answer-key",
-    feedback: "answer-key",
-    // Public, and classified key by key rather than as one leaf — the lesson
-    // `media`, `rubric` and `feedback` each taught: a scalar classification
-    // assigns the author's object by reference without recursing, so an
-    // unclassified key parked inside it survives redact() AND assertRedacted().
-    // An option's picture or recording IS the thing the learner picks, so
-    // stripping it would ship a row of blank options.
-    media: {
-      type: "public",
-      url: "public",
-      alt: "public",
-      captionsUrl: "public"
-    }
-  }
-};
-var GAP_SELECT_FIELD_POLICY = {
-  ...SHARED_PUBLIC_FIELDS,
-  passage: "public",
-  passageHtml: "public",
-  presentation: "public",
-  shuffleChoices: "public",
-  scoringStrategy: "answer-key",
-  feedback: FEEDBACK_FIELD_POLICY,
-  banks: {
-    id: "public",
-    choices: { id: "public", text: "public" }
-  },
-  gaps: {
-    id: "public",
-    bankId: "public",
-    choices: { id: "public", text: "public" },
-    correctChoiceId: "answer-key",
-    feedback: "answer-key"
-  }
-};
-var FILL_IN_THE_BLANKS_FIELD_POLICY = {
-  ...SHARED_PUBLIC_FIELDS,
-  passage: "public",
-  passageHtml: "public",
-  scoringStrategy: "answer-key",
-  feedback: FEEDBACK_FIELD_POLICY,
-  blanks: {
-    id: "public",
-    hint: "public",
-    acceptedAnswers: "answer-key",
-    caseSensitive: "answer-key",
-    trimWhitespace: "answer-key",
-    match: TEXT_MATCH_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.
-  criteria: {
-    name: "public",
-    description: "public",
-    weight: "public"
-  }
-};
-var WRITTEN_RESPONSE_FIELD_POLICY = {
-  ...SHARED_PUBLIC_FIELDS,
-  prompt: "public",
-  promptHtml: "public",
-  minWords: "public",
-  maxWords: "public",
-  languageTarget: "public",
-  feedback: FEEDBACK_FIELD_POLICY,
-  // A rubric is a LEARNER affordance, not a grader secret: it tells the
-  // learner what they are being graded on, which is pedagogically the point
-  // of publishing one. (Classifying it author-only broke real deployments
-  // that render a rubric panel during the attempt.) A deployment that wants
-  // it hidden can tighten this per call via `redact(data, { policy })`.
-  // Classified field by field so that stays true of the rubric's DOCUMENTED
-  // fields only — see {@link RUBRIC_FIELD_POLICY}.
-  rubric: RUBRIC_FIELD_POLICY
-};
-var multipleChoiceType = defineActivityType({
-  type: "multiple-choice",
-  // zod4 optional outputs are `T | undefined`; the hand-written wire types use
-  // exact optionals. Structurally identical at runtime — cast is type-level only.
-  schema: MultipleChoiceDataSchema,
-  scoring: { kind: "sync", score: scoreMultipleChoice },
-  isAnswered: (response) => (response?.selectedOptionIds.length ?? 0) > 0,
-  fieldPolicy: MULTIPLE_CHOICE_FIELD_POLICY,
-  redactedSchema: RedactedMultipleChoiceDataSchema,
-  interop: {
-    xapiActivityTypeIri: "http://adlnet.gov/expapi/activities/cmi.interaction",
-    xapiInteractionType: "choice",
-    correctResponsesPattern: (data) => [
-      data.options.filter((option) => option.isCorrect).map((option) => option.id).join("[,]")
-    ]
-  },
-  interactions: ["option-selected", "option-deselected", "submitted"],
-  authoring: multipleChoiceAuthoring
-});
-var fillInTheBlanksType = defineActivityType({
-  type: "fill-in-the-blanks",
-  schema: FillInTheBlanksDataSchema,
-  scoring: { kind: "sync", score: scoreFillInTheBlanks },
-  isAnswered: (response) => Object.values(response?.answers ?? {}).some((answer) => answer.trim().length > 0),
-  fieldPolicy: FILL_IN_THE_BLANKS_FIELD_POLICY,
-  redactedSchema: RedactedFillInTheBlanksDataSchema,
-  interop: {
-    xapiActivityTypeIri: "http://adlnet.gov/expapi/activities/cmi.interaction",
-    xapiInteractionType: "fill-in",
-    // xAPI fill-in pattern: blank answers joined with "[,]". Only the first
-    // accepted answer per blank is emitted (full alternates would explode
-    // combinatorially); the complete key lives in the activity data.
-    correctResponsesPattern: (data) => [
-      data.blanks.map((blank) => blank.acceptedAnswers[0] ?? "").join("[,]")
-    ]
-  },
-  interactions: ["blank-filled", "hint-requested", "submitted"],
-  authoring: fillInTheBlanksAuthoring
-});
-var writtenResponseType = defineActivityType({
-  type: "written-response",
-  schema: WrittenResponseDataSchema,
-  scoring: {
-    kind: "deferred",
-    reason: "requires_async_grading",
-    partial: (data, response) => {
-      const wordCount = countWords(response?.text ?? "");
-      return {
-        withinWordBounds: response !== void 0 && wordCount >= data.minWords && wordCount <= data.maxWords,
-        wordCount
-      };
-    }
-  },
-  isAnswered: (response) => (response?.text.trim().length ?? 0) > 0,
-  fieldPolicy: WRITTEN_RESPONSE_FIELD_POLICY,
-  redactedSchema: RedactedWrittenResponseDataSchema,
-  interop: {
-    xapiActivityTypeIri: "http://adlnet.gov/expapi/activities/cmi.interaction",
-    xapiInteractionType: "long-fill-in",
-    correctResponsesPattern: () => []
-  },
-  interactions: ["text-changed", "submitted"],
-  authoring: writtenResponseAuthoring
-});
-var gapSelectType = defineActivityType({
-  type: "gap-select",
-  schema: GapSelectDataSchema,
-  scoring: { kind: "sync", score: scoreGapSelect },
-  isAnswered: (response) => Object.values(response?.selections ?? {}).some((choiceId) => choiceId !== ""),
-  fieldPolicy: GAP_SELECT_FIELD_POLICY,
-  redactedSchema: RedactedGapSelectDataSchema,
-  interop: {
-    xapiActivityTypeIri: "http://adlnet.gov/expapi/activities/cmi.interaction",
-    // `matching`, not `choice` or `fill-in`. The learner pairs a set of sources
-    // (the gaps) with a set of targets (the choices), which is exactly what the
-    // xAPI matching interaction describes, and it is the only built-in type
-    // whose pattern can name WHICH gap took which answer. `fill-in` — what the
-    // Fill-in-the-Blanks descriptor uses — would flatten the gaps into an
-    // ordered list of strings and lose that.
-    xapiInteractionType: "matching",
-    correctResponsesPattern: (data) => [
-      data.gaps.map((gap) => `${gap.id}[.]${gap.correctChoiceId}`).join("[,]")
-    ]
-  },
-  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
-});
-var READ_ALOUD_FIELD_POLICY = {
-  ...SHARED_PUBLIC_FIELDS,
-  instructions: "public",
-  referenceText: "public",
-  recording: { maxSeconds: "public", minSeconds: "public", maxTakes: "public" },
-  slowMedia: { type: "public", url: "public", alt: "public" },
-  scoring: { dimensions: { name: "public", weight: "public" } },
-  feedback: FEEDBACK_FIELD_POLICY
-};
-function hasRecording(response) {
-  const recording = response?.recording;
-  return typeof recording === "object" && recording !== null && typeof recording.key === "string" && recording.key !== "";
-}
-var readAloudType = defineActivityType({
-  type: "read-aloud",
-  schema: ReadAloudDataSchema,
-  scoring: {
-    kind: "deferred",
-    reason: "requires_async_grading",
-    partial: (_data, response) => ({ hasRecording: hasRecording(response) })
-  },
-  isAnswered: (response) => hasRecording(response),
-  fieldPolicy: READ_ALOUD_FIELD_POLICY,
-  redactedSchema: RedactedReadAloudDataSchema,
-  interop: {
-    xapiActivityTypeIri: "http://adlnet.gov/expapi/activities/cmi.interaction",
-    // `other`, not `performance`: xAPI's performance interaction describes a set
-    // of steps with their own responses, and a reading has one. There is no
-    // pattern to publish either — the "correct response" is a pronunciation, not
-    // a string a statement can carry.
-    xapiInteractionType: "other",
-    correctResponsesPattern: () => []
-  },
-  interactions: ["recording-started", "recording-stopped", "recording-uploaded", "submitted"],
-  authoring: readAloudAuthoring
-});
-for (const descriptor of [
-  multipleChoiceType,
-  fillInTheBlanksType,
-  writtenResponseType,
-  gapSelectType,
-  dictationType,
-  readAloudType
-]) {
-  ownSchemas(
-    descriptor.schema,
-    ...descriptor.redactedSchema !== void 0 ? [descriptor.redactedSchema] : []
-  );
-}
-registerActivityType(multipleChoiceType);
-registerActivityType(fillInTheBlanksType);
-registerActivityType(writtenResponseType);
-registerActivityType(gapSelectType);
-registerActivityType(dictationType);
-registerActivityType(readAloudType);
-
-export {
-  maxUnits,
-  MediaSchema,
-  RedactedMediaSchema,
-  PLACEHOLDER_RE,
-  FillInTheBlanksDataSchema,
-  withValidationScope,
-  DICTATION_MAX_TRANSCRIPT_LENGTH,
-  DICTATION_MAX_TEXT_LENGTH,
-  DICTATION_MAX_EQUIVALENCE_LENGTH,
-  DICTATION_MAX_EQUIVALENCES,
-  DICTATION_MAX_ACCEPTED_TRANSCRIPTS,
-  codePointLength,
-  normalizeDictationText,
-  dictationReferenceWords,
-  alignDictation,
-  STEP,
-  alignSequences,
-  ActivitySchemaError,
-  UnknownActivityTypeError,
-  RedactedScoringError,
-  DeferredScoringError,
-  DictationDataSchema,
-  groupCaptionsField,
-  GROUP_CAPTIONS_REVEAL_DICTATION,
-  DRAFT_ISSUE_SEVERITY,
-  issue,
-  isRecord,
-  refusesEmpty,
-  isUnset,
-  isUnwritten,
-  isMissingId,
-  checkMedia,
-  covers,
-  pathKey,
-  coveredPathsOf,
-  MultipleChoiceOptionMediaSchema,
-  MultipleChoiceDataSchema,
-  READ_ALOUD_MAX_REFERENCE_LENGTH,
-  READ_ALOUD_MAX_SECONDS,
-  READ_ALOUD_MAX_TAKES,
-  READ_ALOUD_MAX_DIMENSION_WEIGHT,
-  SPEECH_ASSESSMENT_MAX_WORDS,
-  SPEECH_ASSESSMENT_MAX_TEXT_LENGTH,
-  CANONICAL_LOCALE_RE,
-  ReadAloudDataSchema,
-  countWords,
-  GapSelectDataSchema,
-  isOwnSchema,
-  readSchema,
-  standardJsonSchemaOf,
-  WrittenResponseDataSchema,
-  levenshteinDistance,
-  matchText,
-  defineActivityType,
-  registerActivityType,
-  getActivityTypeDescriptor,
-  registeredActivityTypes,
-  MEDIA_FIELD_POLICY,
-  multipleChoiceType,
-  fillInTheBlanksType,
-  writtenResponseType,
-  gapSelectType,
-  dictationType,
-  readAloudType
-};
-//# sourceMappingURL=chunk-FBKTION6.js.map