@intellectif/lk-core 0.13.0 → 0.14.0

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

@@ -20,7 +20,7 @@ var UnknownActivityTypeError = class extends Error {
 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, or use evaluate() which returns { status: "unscorable" }.`
+      `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";
@@ -220,6 +220,10 @@ var SPACE_BESIDE_UNSPACED_RE = new RegExp(
 );
 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;
@@ -1341,6 +1345,168 @@ var MultipleChoiceDataSchema = _v4.z.looseObject({
   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/schemas/read-aloud.ts
+
+
+// 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 = _v4.z.strictObject({
+  type: _v4.z.literal("audio"),
+  url: MediaUrlSchema,
+  alt: _v4.z.string().min(1).optional()
+});
+var ReferenceTextSchema = _v4.z.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 = _v4.z.looseObject({
+  maxSeconds: _v4.z.number().gt(0).max(READ_ALOUD_MAX_SECONDS),
+  minSeconds: _v4.z.number().min(0).optional(),
+  maxTakes: _v4.z.number().int().min(1).max(READ_ALOUD_MAX_TAKES).optional()
+});
+var ReadAloudDimensionWeightSchema = _v4.z.looseObject({
+  name: _v4.z.enum(READ_ALOUD_DIMENSIONS),
+  weight: _v4.z.number().min(0).max(READ_ALOUD_MAX_DIMENSION_WEIGHT)
+});
+var ReadAloudScoringSchema = _v4.z.looseObject({
+  dimensions: _v4.z.array(ReadAloudDimensionWeightSchema).min(1).max(READ_ALOUD_MAX_DIMENSIONS)
+});
+function checkEvenAfterIssues2(check) {
+  const guard = new _v4.z.core.$ZodCheck({ check: "custom", when: () => true });
+  guard._zod.check = check;
+  return guard;
+}
+var ReadAloudDataShape = _v4.z.looseObject({
+  schemaVersion: _v4.z.literal("1.0"),
+  type: _v4.z.literal("read-aloud"),
+  id: _v4.z.string().min(1),
+  title: _v4.z.string().min(1),
+  instructions: _v4.z.string().optional(),
+  referenceText: ReferenceTextSchema,
+  locale: _v4.z.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: _v4.z.number().min(0).max(1).optional(),
+  feedback: FeedbackSchema.optional(),
+  learningObjectives: _v4.z.array(_v4.z.string()).optional(),
+  difficultyLevel: _v4.z.literal([1, 2, 3, 4, 5]).optional()
+});
+var ReadAloudDataSchema = ReadAloudDataShape.check(
+  checkEvenAfterIssues2((ctx) => {
+    if (ctx.issues.some((issue2) => (_nullishCoalesce(_optionalChain([issue2, 'access', _53 => _53.path, 'optionalAccess', _54 => _54.length]), () => ( 0))) === 0)) {
+      return;
+    }
+    const data = ctx.value;
+    const refused = new Set(ctx.issues.map((issue2) => String(_optionalChain([issue2, 'access', _55 => _55.path, 'optionalAccess', _56 => _56[0]]))));
+    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 (_optionalChain([data, 'access', _57 => _57.media, 'optionalAccess', _58 => _58.playback, 'optionalAccess', _59 => _59.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 _optionalChain([data, 'access', _60 => _60.media, 'optionalAccess', _61 => _61.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/count-words.ts
 function countWords(text) {
   if (typeof text !== "string") {
@@ -1377,7 +1543,7 @@ function resolveChoices(gap, banks) {
   if (gap.bankId === void 0) {
     return void 0;
   }
-  return _optionalChain([banks, 'access', _53 => _53.find, 'call', _54 => _54((bank) => bank.id === gap.bankId), 'optionalAccess', _55 => _55.choices]);
+  return _optionalChain([banks, 'access', _62 => _62.find, 'call', _63 => _63((bank) => bank.id === gap.bankId), 'optionalAccess', _64 => _64.choices]);
 }
 function placeholderCounts(passage) {
   const counts = /* @__PURE__ */ new Map();
@@ -1591,7 +1757,7 @@ var RedactedDictationDataSchema = _v4.z.strictObject({
   hints: _v4.z.strictObject({ mode: _v4.z.literal("progressive-words") }).optional()
 }).check((ctx) => {
   const data = ctx.value;
-  if (_optionalChain([data, 'access', _56 => _56.media, 'optionalAccess', _57 => _57.captionsUrl]) !== void 0) {
+  if (_optionalChain([data, 'access', _65 => _65.media, 'optionalAccess', _66 => _66.captionsUrl]) !== void 0) {
     ctx.issues.push({
       code: "custom",
       input: data.media.captionsUrl,
@@ -1599,7 +1765,7 @@ var RedactedDictationDataSchema = _v4.z.strictObject({
       path: ["media", "captionsUrl"]
     });
   }
-  if (data.slowMedia !== void 0 && _optionalChain([data, 'access', _58 => _58.media, 'optionalAccess', _59 => _59.playback, 'optionalAccess', _60 => _60.maxPlays]) !== void 0) {
+  if (data.slowMedia !== void 0 && _optionalChain([data, 'access', _67 => _67.media, 'optionalAccess', _68 => _68.playback, 'optionalAccess', _69 => _69.maxPlays]) !== void 0) {
     ctx.issues.push({
       code: "custom",
       input: data.slowMedia,
@@ -1616,6 +1782,61 @@ var RedactedDictationDataSchema = _v4.z.strictObject({
     });
   }
 });
+var RedactedReadAloudDataSchema = _v4.z.strictObject({
+  ...redactedBase,
+  type: _v4.z.literal("read-aloud"),
+  locale: _v4.z.string().regex(CANONICAL_LOCALE_RE),
+  instructions: _v4.z.string().optional(),
+  referenceText: _v4.z.string().min(1),
+  slowMedia: ReadAloudSlowMediaSchema.optional(),
+  recording: _v4.z.strictObject({
+    maxSeconds: _v4.z.number().gt(0).max(READ_ALOUD_MAX_SECONDS),
+    minSeconds: _v4.z.number().min(0).optional(),
+    maxTakes: _v4.z.number().int().min(1).max(READ_ALOUD_MAX_TAKES).optional()
+  }),
+  scoring: _v4.z.strictObject({
+    dimensions: _v4.z.array(
+      _v4.z.strictObject({
+        name: _v4.z.enum(READ_ALOUD_DIMENSIONS),
+        weight: _v4.z.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 && _optionalChain([data, 'access', _70 => _70.media, 'optionalAccess', _71 => _71.playback, 'optionalAccess', _72 => _72.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 === _optionalChain([data, 'access', _73 => _73.media, 'optionalAccess', _74 => _74.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/dictation/edit-distance.ts
 function codePoints(text) {
@@ -2037,7 +2258,27 @@ var DRAFT_ISSUE_SEVERITY = {
   dc_hints_mode_invalid: "invalid",
   dc_equivalence_from_required: "incomplete",
   dc_equivalence_to_required: "incomplete",
-  dc_tolerance_invalid: "invalid"
+  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] };
@@ -3178,6 +3419,283 @@ function checkOptionMedia(media, index, ordinal) {
   return checkMedia(media, path, MultipleChoiceOptionMediaSchema);
 }
 
+// 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 }) => ({
@@ -3321,7 +3839,7 @@ function checkCriteria(criteria) {
 
 // src/scoring/activity-scorers/dictation.ts
 function scoreDictation(data, response) {
-  const alignment = alignDictation(data, typeof _optionalChain([response, 'optionalAccess', _61 => _61.text]) === "string" ? response.text : "");
+  const alignment = alignDictation(data, typeof _optionalChain([response, 'optionalAccess', _75 => _75.text]) === "string" ? response.text : "");
   const details = [];
   for (const word of alignment.words) {
     if (word.status === "extra") {
@@ -3390,7 +3908,7 @@ function choicesFor(data, gap) {
   if (gap.choices !== void 0) {
     return gap.choices;
   }
-  return _nullishCoalesce(_optionalChain([data, 'access', _62 => _62.banks, 'optionalAccess', _63 => _63.find, 'call', _64 => _64((bank) => bank.id === gap.bankId), 'optionalAccess', _65 => _65.choices]), () => ( []));
+  return _nullishCoalesce(_optionalChain([data, 'access', _76 => _76.banks, 'optionalAccess', _77 => _77.find, 'call', _78 => _78((bank) => bank.id === gap.bankId), 'optionalAccess', _79 => _79.choices]), () => ( []));
 }
 function scoreGapSelect(data, response) {
   const details = [];
@@ -3426,7 +3944,7 @@ function scoreMultipleChoice(data, response) {
   let scoreValue;
   if (data.scoringStrategy === "all-or-nothing") {
     if (data.mode === "single") {
-      scoreValue = response.selectedOptionIds.length === 1 && _optionalChain([optionById, 'access', _66 => _66.get, 'call', _67 => _67(response.selectedOptionIds[0]), 'optionalAccess', _68 => _68.isCorrect]) === true ? 1 : 0;
+      scoreValue = response.selectedOptionIds.length === 1 && _optionalChain([optionById, 'access', _80 => _80.get, 'call', _81 => _81(response.selectedOptionIds[0]), 'optionalAccess', _82 => _82.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));
@@ -3437,7 +3955,7 @@ function scoreMultipleChoice(data, response) {
     let incorrectSelected = 0;
     for (const id of selected) {
       const option = optionById.get(id);
-      if (_optionalChain([option, 'optionalAccess', _69 => _69.isCorrect])) {
+      if (_optionalChain([option, 'optionalAccess', _83 => _83.isCorrect])) {
         correctSelected += 1;
       } else {
         incorrectSelected += 1;
@@ -3608,7 +4126,7 @@ var multipleChoiceType = defineActivityType({
   // exact optionals. Structurally identical at runtime — cast is type-level only.
   schema: MultipleChoiceDataSchema,
   scoring: { kind: "sync", score: scoreMultipleChoice },
-  isAnswered: (response) => (_nullishCoalesce(_optionalChain([response, 'optionalAccess', _70 => _70.selectedOptionIds, 'access', _71 => _71.length]), () => ( 0))) > 0,
+  isAnswered: (response) => (_nullishCoalesce(_optionalChain([response, 'optionalAccess', _84 => _84.selectedOptionIds, 'access', _85 => _85.length]), () => ( 0))) > 0,
   fieldPolicy: MULTIPLE_CHOICE_FIELD_POLICY,
   redactedSchema: RedactedMultipleChoiceDataSchema,
   interop: {
@@ -3625,7 +4143,7 @@ var fillInTheBlanksType = defineActivityType({
   type: "fill-in-the-blanks",
   schema: FillInTheBlanksDataSchema,
   scoring: { kind: "sync", score: scoreFillInTheBlanks },
-  isAnswered: (response) => Object.values(_nullishCoalesce(_optionalChain([response, 'optionalAccess', _72 => _72.answers]), () => ( {}))).some((answer) => answer.trim().length > 0),
+  isAnswered: (response) => Object.values(_nullishCoalesce(_optionalChain([response, 'optionalAccess', _86 => _86.answers]), () => ( {}))).some((answer) => answer.trim().length > 0),
   fieldPolicy: FILL_IN_THE_BLANKS_FIELD_POLICY,
   redactedSchema: RedactedFillInTheBlanksDataSchema,
   interop: {
@@ -3648,14 +4166,14 @@ var writtenResponseType = defineActivityType({
     kind: "deferred",
     reason: "requires_async_grading",
     partial: (data, response) => {
-      const wordCount = countWords(_nullishCoalesce(_optionalChain([response, 'optionalAccess', _73 => _73.text]), () => ( "")));
+      const wordCount = countWords(_nullishCoalesce(_optionalChain([response, 'optionalAccess', _87 => _87.text]), () => ( "")));
       return {
         withinWordBounds: response !== void 0 && wordCount >= data.minWords && wordCount <= data.maxWords,
         wordCount
       };
     }
   },
-  isAnswered: (response) => (_nullishCoalesce(_optionalChain([response, 'optionalAccess', _74 => _74.text, 'access', _75 => _75.trim, 'call', _76 => _76(), 'access', _77 => _77.length]), () => ( 0))) > 0,
+  isAnswered: (response) => (_nullishCoalesce(_optionalChain([response, 'optionalAccess', _88 => _88.text, 'access', _89 => _89.trim, 'call', _90 => _90(), 'access', _91 => _91.length]), () => ( 0))) > 0,
   fieldPolicy: WRITTEN_RESPONSE_FIELD_POLICY,
   redactedSchema: RedactedWrittenResponseDataSchema,
   interop: {
@@ -3670,7 +4188,7 @@ var gapSelectType = defineActivityType({
   type: "gap-select",
   schema: GapSelectDataSchema,
   scoring: { kind: "sync", score: scoreGapSelect },
-  isAnswered: (response) => Object.values(_nullishCoalesce(_optionalChain([response, 'optionalAccess', _78 => _78.selections]), () => ( {}))).some((choiceId) => choiceId !== ""),
+  isAnswered: (response) => Object.values(_nullishCoalesce(_optionalChain([response, 'optionalAccess', _92 => _92.selections]), () => ( {}))).some((choiceId) => choiceId !== ""),
   fieldPolicy: GAP_SELECT_FIELD_POLICY,
   redactedSchema: RedactedGapSelectDataSchema,
   interop: {
@@ -3701,7 +4219,7 @@ var dictationType = defineActivityType({
   // cut where the scorer cuts, so text past the cap never counts as an answer.
   isAnswered: (response) => normalizeDictationText(
     truncateCodePoints(
-      typeof _optionalChain([response, 'optionalAccess', _79 => _79.text]) === "string" ? response.text : "",
+      typeof _optionalChain([response, 'optionalAccess', _93 => _93.text]) === "string" ? response.text : "",
       DICTATION_MAX_TEXT_LENGTH
     )
   ) !== "",
@@ -3717,11 +4235,61 @@ var dictationType = defineActivityType({
   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 = _optionalChain([response, 'optionalAccess', _94 => _94.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
+});
 registerActivityType(multipleChoiceType);
 registerActivityType(fillInTheBlanksType);
 registerActivityType(writtenResponseType);
 registerActivityType(gapSelectType);
 registerActivityType(dictationType);
+registerActivityType(readAloudType);
+
+
+
+
+
+
+
+
+
+
+
+
+
 
 
 
@@ -3799,5 +4367,5 @@ registerActivityType(dictationType);
 
 
 
-exports.ActivitySchemaError = ActivitySchemaError; exports.UnknownActivityTypeError = UnknownActivityTypeError; exports.RedactedScoringError = RedactedScoringError; exports.DeferredScoringError = DeferredScoringError; exports.withValidationScope = withValidationScope; exports.DICTATION_MAX_TRANSCRIPT_LENGTH = DICTATION_MAX_TRANSCRIPT_LENGTH; exports.DICTATION_MAX_TEXT_LENGTH = DICTATION_MAX_TEXT_LENGTH; exports.DICTATION_MAX_EQUIVALENCE_LENGTH = DICTATION_MAX_EQUIVALENCE_LENGTH; exports.DICTATION_MAX_EQUIVALENCES = DICTATION_MAX_EQUIVALENCES; exports.DICTATION_MAX_ACCEPTED_TRANSCRIPTS = DICTATION_MAX_ACCEPTED_TRANSCRIPTS; exports.FeedbackSchema = FeedbackSchema; exports.MediaUrlSchema = MediaUrlSchema; exports.NativeControlHintSchema = NativeControlHintSchema; exports.MediaPlaybackSchema = MediaPlaybackSchema; exports.MediaSchema = MediaSchema; exports.RedactedMediaSchema = RedactedMediaSchema; exports.DictationSlowMediaSchema = DictationSlowMediaSchema; exports.DictationEquivalenceSchema = DictationEquivalenceSchema; exports.DictationToleranceSchema = DictationToleranceSchema; exports.DictationDataSchema = DictationDataSchema; exports.groupCaptionsRevealDictation = groupCaptionsRevealDictation; exports.GROUP_CAPTIONS_REVEAL_DICTATION = GROUP_CAPTIONS_REVEAL_DICTATION; exports.DRAFT_ISSUE_SEVERITY = DRAFT_ISSUE_SEVERITY; exports.issue = issue; exports.isRecord = isRecord; exports.refusesEmpty = refusesEmpty; exports.isUnset = isUnset; exports.isUnwritten = isUnwritten; exports.isMissingId = isMissingId; exports.checkMedia = checkMedia; exports.covers = covers; exports.pathKey = pathKey; exports.coveredPathsOf = coveredPathsOf; exports.TextMatchPolicySchema = TextMatchPolicySchema; exports.BlankConfigSchema = BlankConfigSchema; exports.FillInTheBlanksDataSchema = FillInTheBlanksDataSchema; exports.MultipleChoiceOptionMediaSchema = MultipleChoiceOptionMediaSchema; exports.MultipleChoiceOptionSchema = MultipleChoiceOptionSchema; exports.MultipleChoiceDataSchema = MultipleChoiceDataSchema; exports.countWords = countWords; exports.GapSelectChoiceSchema = GapSelectChoiceSchema; exports.GapSelectBankSchema = GapSelectBankSchema; exports.GapSelectGapSchema = GapSelectGapSchema; exports.GapSelectDataSchema = GapSelectDataSchema; exports.WrittenResponseRubricCriterionSchema = WrittenResponseRubricCriterionSchema; exports.WrittenResponseRubricSchema = WrittenResponseRubricSchema; exports.WrittenResponseDataSchema = WrittenResponseDataSchema; exports.RedactedMultipleChoiceOptionMediaSchema = RedactedMultipleChoiceOptionMediaSchema; exports.RedactedMultipleChoiceOptionSchema = RedactedMultipleChoiceOptionSchema; exports.RedactedMultipleChoiceDataSchema = RedactedMultipleChoiceDataSchema; exports.RedactedBlankConfigSchema = RedactedBlankConfigSchema; exports.RedactedFillInTheBlanksDataSchema = RedactedFillInTheBlanksDataSchema; exports.RedactedGapSelectChoiceSchema = RedactedGapSelectChoiceSchema; exports.RedactedGapSelectBankSchema = RedactedGapSelectBankSchema; exports.RedactedGapSelectGapSchema = RedactedGapSelectGapSchema; exports.RedactedGapSelectDataSchema = RedactedGapSelectDataSchema; exports.RedactedWrittenResponseDataSchema = RedactedWrittenResponseDataSchema; exports.RedactedDictationSlowMediaSchema = RedactedDictationSlowMediaSchema; exports.RedactedDictationDataSchema = RedactedDictationDataSchema; exports.dictationReferenceWords = dictationReferenceWords; exports.alignDictation = alignDictation; exports.STEP = STEP; exports.alignSequences = alignSequences; exports.levenshteinDistance = levenshteinDistance; exports.matchText = matchText; exports.defineActivityType = defineActivityType; exports.registerActivityType = registerActivityType; exports.getActivityTypeDescriptor = getActivityTypeDescriptor; exports.registeredActivityTypes = registeredActivityTypes; exports.MEDIA_FIELD_POLICY = MEDIA_FIELD_POLICY; exports.multipleChoiceType = multipleChoiceType; exports.fillInTheBlanksType = fillInTheBlanksType; exports.writtenResponseType = writtenResponseType; exports.gapSelectType = gapSelectType; exports.dictationType = dictationType;
-//# sourceMappingURL=chunk-XONKWL6D.cjs.map
+exports.ActivitySchemaError = ActivitySchemaError; exports.UnknownActivityTypeError = UnknownActivityTypeError; exports.RedactedScoringError = RedactedScoringError; exports.DeferredScoringError = DeferredScoringError; exports.withValidationScope = withValidationScope; exports.DICTATION_MAX_TRANSCRIPT_LENGTH = DICTATION_MAX_TRANSCRIPT_LENGTH; exports.DICTATION_MAX_TEXT_LENGTH = DICTATION_MAX_TEXT_LENGTH; exports.DICTATION_MAX_EQUIVALENCE_LENGTH = DICTATION_MAX_EQUIVALENCE_LENGTH; exports.DICTATION_MAX_EQUIVALENCES = DICTATION_MAX_EQUIVALENCES; exports.DICTATION_MAX_ACCEPTED_TRANSCRIPTS = DICTATION_MAX_ACCEPTED_TRANSCRIPTS; exports.codePointLength = codePointLength; exports.normalizeDictationText = normalizeDictationText; exports.FeedbackSchema = FeedbackSchema; exports.MediaUrlSchema = MediaUrlSchema; exports.NativeControlHintSchema = NativeControlHintSchema; exports.MediaPlaybackSchema = MediaPlaybackSchema; exports.MediaSchema = MediaSchema; exports.RedactedMediaSchema = RedactedMediaSchema; exports.DictationSlowMediaSchema = DictationSlowMediaSchema; exports.DictationEquivalenceSchema = DictationEquivalenceSchema; exports.DictationToleranceSchema = DictationToleranceSchema; exports.DictationDataSchema = DictationDataSchema; exports.groupCaptionsRevealDictation = groupCaptionsRevealDictation; exports.GROUP_CAPTIONS_REVEAL_DICTATION = GROUP_CAPTIONS_REVEAL_DICTATION; exports.DRAFT_ISSUE_SEVERITY = DRAFT_ISSUE_SEVERITY; exports.issue = issue; exports.isRecord = isRecord; exports.refusesEmpty = refusesEmpty; exports.isUnset = isUnset; exports.isUnwritten = isUnwritten; exports.isMissingId = isMissingId; exports.checkMedia = checkMedia; exports.covers = covers; exports.pathKey = pathKey; exports.coveredPathsOf = coveredPathsOf; exports.TextMatchPolicySchema = TextMatchPolicySchema; exports.BlankConfigSchema = BlankConfigSchema; exports.FillInTheBlanksDataSchema = FillInTheBlanksDataSchema; exports.MultipleChoiceOptionMediaSchema = MultipleChoiceOptionMediaSchema; exports.MultipleChoiceOptionSchema = MultipleChoiceOptionSchema; exports.MultipleChoiceDataSchema = MultipleChoiceDataSchema; exports.READ_ALOUD_MAX_REFERENCE_LENGTH = READ_ALOUD_MAX_REFERENCE_LENGTH; exports.READ_ALOUD_MAX_SECONDS = READ_ALOUD_MAX_SECONDS; exports.READ_ALOUD_MAX_TAKES = READ_ALOUD_MAX_TAKES; exports.READ_ALOUD_MAX_DIMENSION_WEIGHT = READ_ALOUD_MAX_DIMENSION_WEIGHT; exports.SPEECH_ASSESSMENT_MAX_WORDS = SPEECH_ASSESSMENT_MAX_WORDS; exports.SPEECH_ASSESSMENT_MAX_TEXT_LENGTH = SPEECH_ASSESSMENT_MAX_TEXT_LENGTH; exports.CANONICAL_LOCALE_RE = CANONICAL_LOCALE_RE; exports.ReadAloudSlowMediaSchema = ReadAloudSlowMediaSchema; exports.ReadAloudDataSchema = ReadAloudDataSchema; exports.countWords = countWords; exports.GapSelectChoiceSchema = GapSelectChoiceSchema; exports.GapSelectBankSchema = GapSelectBankSchema; exports.GapSelectGapSchema = GapSelectGapSchema; exports.GapSelectDataSchema = GapSelectDataSchema; exports.WrittenResponseRubricCriterionSchema = WrittenResponseRubricCriterionSchema; exports.WrittenResponseRubricSchema = WrittenResponseRubricSchema; exports.WrittenResponseDataSchema = WrittenResponseDataSchema; exports.RedactedMultipleChoiceOptionMediaSchema = RedactedMultipleChoiceOptionMediaSchema; exports.RedactedMultipleChoiceOptionSchema = RedactedMultipleChoiceOptionSchema; exports.RedactedMultipleChoiceDataSchema = RedactedMultipleChoiceDataSchema; exports.RedactedBlankConfigSchema = RedactedBlankConfigSchema; exports.RedactedFillInTheBlanksDataSchema = RedactedFillInTheBlanksDataSchema; exports.RedactedGapSelectChoiceSchema = RedactedGapSelectChoiceSchema; exports.RedactedGapSelectBankSchema = RedactedGapSelectBankSchema; exports.RedactedGapSelectGapSchema = RedactedGapSelectGapSchema; exports.RedactedGapSelectDataSchema = RedactedGapSelectDataSchema; exports.RedactedWrittenResponseDataSchema = RedactedWrittenResponseDataSchema; exports.RedactedDictationSlowMediaSchema = RedactedDictationSlowMediaSchema; exports.RedactedDictationDataSchema = RedactedDictationDataSchema; exports.RedactedReadAloudDataSchema = RedactedReadAloudDataSchema; exports.dictationReferenceWords = dictationReferenceWords; exports.alignDictation = alignDictation; exports.STEP = STEP; exports.alignSequences = alignSequences; exports.levenshteinDistance = levenshteinDistance; exports.matchText = matchText; exports.defineActivityType = defineActivityType; exports.registerActivityType = registerActivityType; exports.getActivityTypeDescriptor = getActivityTypeDescriptor; exports.registeredActivityTypes = registeredActivityTypes; exports.MEDIA_FIELD_POLICY = MEDIA_FIELD_POLICY; exports.multipleChoiceType = multipleChoiceType; exports.fillInTheBlanksType = fillInTheBlanksType; exports.writtenResponseType = writtenResponseType; exports.gapSelectType = gapSelectType; exports.dictationType = dictationType; exports.readAloudType = readAloudType;
+//# sourceMappingURL=chunk-VCXIPLEW.cjs.map