@intellectif/lk-core 0.13.1 → 0.14.1

package/dist/{chunk-XKKKWKRH.js → chunk-6RND47QE.js}

@@ -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 = z5.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
+import { z as z6 } 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 = z6.strictObject({
+  type: z6.literal("audio"),
+  url: MediaUrlSchema,
+  alt: z6.string().min(1).optional()
+});
+var ReferenceTextSchema = z6.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 = z6.looseObject({
+  maxSeconds: z6.number().gt(0).max(READ_ALOUD_MAX_SECONDS),
+  minSeconds: z6.number().min(0).optional(),
+  maxTakes: z6.number().int().min(1).max(READ_ALOUD_MAX_TAKES).optional()
+});
+var ReadAloudDimensionWeightSchema = z6.looseObject({
+  name: z6.enum(READ_ALOUD_DIMENSIONS),
+  weight: z6.number().min(0).max(READ_ALOUD_MAX_DIMENSION_WEIGHT)
+});
+var ReadAloudScoringSchema = z6.looseObject({
+  dimensions: z6.array(ReadAloudDimensionWeightSchema).min(1).max(READ_ALOUD_MAX_DIMENSIONS)
+});
+function checkEvenAfterIssues2(check) {
+  const guard = new z6.core.$ZodCheck({ check: "custom", when: () => true });
+  guard._zod.check = check;
+  return guard;
+}
+var ReadAloudDataShape = z6.looseObject({
+  schemaVersion: z6.literal("1.0"),
+  type: z6.literal("read-aloud"),
+  id: z6.string().min(1),
+  title: z6.string().min(1),
+  instructions: z6.string().optional(),
+  referenceText: ReferenceTextSchema,
+  locale: z6.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: z6.number().min(0).max(1).optional(),
+  feedback: FeedbackSchema.optional(),
+  learningObjectives: z6.array(z6.string()).optional(),
+  difficultyLevel: z6.literal([1, 2, 3, 4, 5]).optional()
+});
+var ReadAloudDataSchema = ReadAloudDataShape.check(
+  checkEvenAfterIssues2((ctx) => {
+    if (ctx.issues.some((issue2) => (issue2.path?.length ?? 0) === 0)) {
+      return;
+    }
+    const data = ctx.value;
+    const refused = new Set(ctx.issues.map((issue2) => String(issue2.path?.[0])));
+    const report = (path, input, message) => {
+      ctx.issues.push({ code: "custom", input, message, path: [...path] });
+    };
+    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/count-words.ts
 function countWords(text) {
   if (typeof text !== "string") {
@@ -1354,21 +1520,21 @@ function countWords(text) {
 }
 
 // src/schemas/gap-select.ts
-import { z as z6 } from "zod/v4";
-var GapSelectChoiceSchema = z6.looseObject({
-  id: z6.string().min(1),
-  text: z6.string().min(1)
+import { z as z7 } from "zod/v4";
+var GapSelectChoiceSchema = z7.looseObject({
+  id: z7.string().min(1),
+  text: z7.string().min(1)
 });
-var GapSelectBankSchema = z6.looseObject({
-  id: z6.string().min(1),
-  choices: z6.array(GapSelectChoiceSchema).min(2)
+var GapSelectBankSchema = z7.looseObject({
+  id: z7.string().min(1),
+  choices: z7.array(GapSelectChoiceSchema).min(2)
 });
-var GapSelectGapSchema = z6.looseObject({
-  id: z6.string().min(1),
-  choices: z6.array(GapSelectChoiceSchema).min(2).optional(),
-  bankId: z6.string().min(1).optional(),
-  correctChoiceId: z6.string().min(1),
-  feedback: z6.string().optional()
+var GapSelectGapSchema = z7.looseObject({
+  id: z7.string().min(1),
+  choices: z7.array(GapSelectChoiceSchema).min(2).optional(),
+  bankId: z7.string().min(1).optional(),
+  correctChoiceId: z7.string().min(1),
+  feedback: z7.string().optional()
 });
 function resolveChoices(gap, banks) {
   if (gap.choices !== void 0) {
@@ -1387,24 +1553,24 @@ function placeholderCounts(passage) {
   }
   return counts;
 }
-var GapSelectDataSchema = z6.looseObject({
-  schemaVersion: z6.literal("1.0"),
-  type: z6.literal("gap-select"),
-  id: z6.string().min(1),
-  title: z6.string().min(1),
-  passage: z6.string().min(1),
-  passageHtml: z6.string().optional(),
-  gaps: z6.array(GapSelectGapSchema).min(1),
-  banks: z6.array(GapSelectBankSchema).optional(),
-  scoringStrategy: z6.enum(["all-or-nothing", "partial"]),
-  presentation: z6.literal("dropdown").optional(),
-  shuffleChoices: z6.boolean().optional(),
+var GapSelectDataSchema = z7.looseObject({
+  schemaVersion: z7.literal("1.0"),
+  type: z7.literal("gap-select"),
+  id: z7.string().min(1),
+  title: z7.string().min(1),
+  passage: z7.string().min(1),
+  passageHtml: z7.string().optional(),
+  gaps: z7.array(GapSelectGapSchema).min(1),
+  banks: z7.array(GapSelectBankSchema).optional(),
+  scoringStrategy: z7.enum(["all-or-nothing", "partial"]),
+  presentation: z7.literal("dropdown").optional(),
+  shuffleChoices: z7.boolean().optional(),
   media: MediaSchema.optional(),
   feedback: FeedbackSchema.optional(),
-  passThreshold: z6.number().min(0).max(1).optional(),
-  locale: z6.string().optional(),
-  learningObjectives: z6.array(z6.string()).optional(),
-  difficultyLevel: z6.literal([1, 2, 3, 4, 5]).optional()
+  passThreshold: z7.number().min(0).max(1).optional(),
+  locale: z7.string().optional(),
+  learningObjectives: z7.array(z7.string()).optional(),
+  difficultyLevel: z7.literal([1, 2, 3, 4, 5]).optional()
 }).refine(
   (data) => {
     const ids = (data.banks ?? []).map((bank) => bank.id);
@@ -1458,137 +1624,137 @@ var GapSelectDataSchema = z6.looseObject({
 );
 
 // src/schemas/written-response.ts
-import { z as z7 } from "zod/v4";
-var WrittenResponseRubricCriterionSchema = z7.looseObject({
-  name: z7.string().min(1),
-  description: z7.string().optional(),
-  weight: z7.number().min(0)
+import { z as z8 } from "zod/v4";
+var WrittenResponseRubricCriterionSchema = z8.looseObject({
+  name: z8.string().min(1),
+  description: z8.string().optional(),
+  weight: z8.number().min(0)
 });
-var WrittenResponseRubricSchema = z7.looseObject({
-  label: z7.string().optional(),
-  criteria: z7.array(WrittenResponseRubricCriterionSchema).min(1)
+var WrittenResponseRubricSchema = z8.looseObject({
+  label: z8.string().optional(),
+  criteria: z8.array(WrittenResponseRubricCriterionSchema).min(1)
 });
-var RedactedWrittenResponseRubricCriterionSchema = z7.strictObject({
-  name: z7.string().min(1),
-  description: z7.string().optional(),
-  weight: z7.number().min(0)
+var RedactedWrittenResponseRubricCriterionSchema = z8.strictObject({
+  name: z8.string().min(1),
+  description: z8.string().optional(),
+  weight: z8.number().min(0)
 });
-var RedactedWrittenResponseRubricSchema = z7.strictObject({
-  label: z7.string().optional(),
-  criteria: z7.array(RedactedWrittenResponseRubricCriterionSchema).min(1)
+var RedactedWrittenResponseRubricSchema = z8.strictObject({
+  label: z8.string().optional(),
+  criteria: z8.array(RedactedWrittenResponseRubricCriterionSchema).min(1)
 });
-var WrittenResponseDataSchema = z7.looseObject({
-  schemaVersion: z7.literal("1.0"),
-  type: z7.literal("written-response"),
-  id: z7.string().min(1),
-  title: z7.string().min(1),
-  prompt: z7.string(),
-  promptHtml: z7.string().optional(),
-  minWords: z7.number().int().min(0),
-  maxWords: z7.number().int().min(1),
+var WrittenResponseDataSchema = z8.looseObject({
+  schemaVersion: z8.literal("1.0"),
+  type: z8.literal("written-response"),
+  id: z8.string().min(1),
+  title: z8.string().min(1),
+  prompt: z8.string(),
+  promptHtml: z8.string().optional(),
+  minWords: z8.number().int().min(0),
+  maxWords: z8.number().int().min(1),
   rubric: WrittenResponseRubricSchema.optional(),
-  languageTarget: z7.string().optional(),
+  languageTarget: z8.string().optional(),
   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()
+  passThreshold: z8.number().min(0).max(1).optional(),
+  locale: z8.string().optional(),
+  learningObjectives: z8.array(z8.string()).optional(),
+  difficultyLevel: z8.literal([1, 2, 3, 4, 5]).optional()
 }).refine((data) => data.maxWords >= data.minWords, {
   error: "maxWords must be greater than or equal to minWords.",
   path: ["maxWords"]
 });
 
 // src/schemas/redacted.ts
-import { z as z8 } from "zod/v4";
+import { z as z9 } from "zod/v4";
 var redactedBase = {
   /** Marker distinguishing a redacted projection from full activity data. */
-  redacted: z8.literal(true),
+  redacted: z9.literal(true),
   /** Slot identity, carried through redaction so the client and the plan agree. */
-  slotKey: z8.string().min(1).optional(),
-  schemaVersion: z8.literal("1.0"),
-  id: z8.string().min(1),
-  title: z8.string().min(1),
+  slotKey: z9.string().min(1).optional(),
+  schemaVersion: z9.literal("1.0"),
+  id: z9.string().min(1),
+  title: z9.string().min(1),
   media: RedactedMediaSchema.optional(),
-  passThreshold: z8.number().min(0).max(1).optional(),
-  locale: z8.string().optional(),
-  learningObjectives: z8.array(z8.string()).optional(),
-  difficultyLevel: z8.literal([1, 2, 3, 4, 5]).optional()
+  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()
 };
-var RedactedMultipleChoiceOptionMediaSchema = z8.strictObject({
-  type: z8.enum(["image", "audio"]),
-  url: z8.string().min(1),
-  alt: z8.string().min(1).optional(),
-  captionsUrl: z8.string().min(1).optional()
+var RedactedMultipleChoiceOptionMediaSchema = z9.strictObject({
+  type: z9.enum(["image", "audio"]),
+  url: z9.string().min(1),
+  alt: z9.string().min(1).optional(),
+  captionsUrl: z9.string().min(1).optional()
 });
-var RedactedMultipleChoiceOptionSchema = z8.strictObject({
-  id: z8.string().min(1),
-  text: z8.string().min(1),
+var RedactedMultipleChoiceOptionSchema = z9.strictObject({
+  id: z9.string().min(1),
+  text: z9.string().min(1),
   media: RedactedMultipleChoiceOptionMediaSchema.optional()
 });
-var RedactedMultipleChoiceDataSchema = z8.strictObject({
+var RedactedMultipleChoiceDataSchema = z9.strictObject({
   ...redactedBase,
-  type: z8.literal("multiple-choice"),
-  question: z8.string().min(1),
-  questionHtml: z8.string().optional(),
-  mode: z8.enum(["single", "multi"]),
-  options: z8.array(RedactedMultipleChoiceOptionSchema).min(2).max(26),
-  shuffle: z8.boolean().optional()
+  type: z9.literal("multiple-choice"),
+  question: z9.string().min(1),
+  questionHtml: z9.string().optional(),
+  mode: z9.enum(["single", "multi"]),
+  options: z9.array(RedactedMultipleChoiceOptionSchema).min(2).max(26),
+  shuffle: z9.boolean().optional()
 });
-var RedactedBlankConfigSchema = z8.strictObject({
-  id: z8.string().min(1),
-  hint: z8.string().optional()
+var RedactedBlankConfigSchema = z9.strictObject({
+  id: z9.string().min(1),
+  hint: z9.string().optional()
 });
-var RedactedFillInTheBlanksDataSchema = z8.strictObject({
+var RedactedFillInTheBlanksDataSchema = z9.strictObject({
   ...redactedBase,
-  type: z8.literal("fill-in-the-blanks"),
-  passage: z8.string().min(1),
-  passageHtml: z8.string().optional(),
-  blanks: z8.array(RedactedBlankConfigSchema).min(1)
+  type: z9.literal("fill-in-the-blanks"),
+  passage: z9.string().min(1),
+  passageHtml: z9.string().optional(),
+  blanks: z9.array(RedactedBlankConfigSchema).min(1)
 });
-var RedactedGapSelectChoiceSchema = z8.strictObject({
-  id: z8.string().min(1),
-  text: z8.string().min(1)
+var RedactedGapSelectChoiceSchema = z9.strictObject({
+  id: z9.string().min(1),
+  text: z9.string().min(1)
 });
-var RedactedGapSelectBankSchema = z8.strictObject({
-  id: z8.string().min(1),
-  choices: z8.array(RedactedGapSelectChoiceSchema).min(2)
+var RedactedGapSelectBankSchema = z9.strictObject({
+  id: z9.string().min(1),
+  choices: z9.array(RedactedGapSelectChoiceSchema).min(2)
 });
-var RedactedGapSelectGapSchema = z8.strictObject({
-  id: z8.string().min(1),
-  choices: z8.array(RedactedGapSelectChoiceSchema).min(2).optional(),
-  bankId: z8.string().min(1).optional()
+var RedactedGapSelectGapSchema = z9.strictObject({
+  id: z9.string().min(1),
+  choices: z9.array(RedactedGapSelectChoiceSchema).min(2).optional(),
+  bankId: z9.string().min(1).optional()
 });
-var RedactedGapSelectDataSchema = z8.strictObject({
+var RedactedGapSelectDataSchema = z9.strictObject({
   ...redactedBase,
-  type: z8.literal("gap-select"),
-  passage: z8.string().min(1),
-  passageHtml: z8.string().optional(),
-  gaps: z8.array(RedactedGapSelectGapSchema).min(1),
-  banks: z8.array(RedactedGapSelectBankSchema).optional(),
-  presentation: z8.literal("dropdown").optional(),
-  shuffleChoices: z8.boolean().optional()
+  type: z9.literal("gap-select"),
+  passage: z9.string().min(1),
+  passageHtml: z9.string().optional(),
+  gaps: z9.array(RedactedGapSelectGapSchema).min(1),
+  banks: z9.array(RedactedGapSelectBankSchema).optional(),
+  presentation: z9.literal("dropdown").optional(),
+  shuffleChoices: z9.boolean().optional()
 });
-var RedactedWrittenResponseDataSchema = z8.strictObject({
+var RedactedWrittenResponseDataSchema = z9.strictObject({
   ...redactedBase,
-  type: z8.literal("written-response"),
-  prompt: z8.string(),
-  promptHtml: z8.string().optional(),
-  minWords: z8.number().int().min(0),
-  maxWords: z8.number().int().min(1),
+  type: z9.literal("written-response"),
+  prompt: z9.string(),
+  promptHtml: z9.string().optional(),
+  minWords: z9.number().int().min(0),
+  maxWords: z9.number().int().min(1),
   rubric: RedactedWrittenResponseRubricSchema.optional(),
-  languageTarget: z8.string().optional()
+  languageTarget: z9.string().optional()
 });
-var RedactedDictationSlowMediaSchema = z8.strictObject({
-  type: z8.literal("audio"),
+var RedactedDictationSlowMediaSchema = z9.strictObject({
+  type: z9.literal("audio"),
   url: MediaUrlSchema,
-  alt: z8.string().min(1).optional()
+  alt: z9.string().min(1).optional()
 });
-var RedactedDictationDataSchema = z8.strictObject({
+var RedactedDictationDataSchema = z9.strictObject({
   ...redactedBase,
-  type: z8.literal("dictation"),
+  type: z9.literal("dictation"),
   slowMedia: RedactedDictationSlowMediaSchema.optional(),
-  hints: z8.strictObject({ mode: z8.literal("progressive-words") }).optional()
+  hints: z9.strictObject({ mode: z9.literal("progressive-words") }).optional()
 }).check((ctx) => {
   const data = ctx.value;
   if (data.media?.captionsUrl !== void 0) {
@@ -1616,6 +1782,61 @@ var RedactedDictationDataSchema = z8.strictObject({
     });
   }
 });
+var RedactedReadAloudDataSchema = z9.strictObject({
+  ...redactedBase,
+  type: z9.literal("read-aloud"),
+  locale: z9.string().regex(CANONICAL_LOCALE_RE),
+  instructions: z9.string().optional(),
+  referenceText: z9.string().min(1),
+  slowMedia: ReadAloudSlowMediaSchema.optional(),
+  recording: z9.strictObject({
+    maxSeconds: z9.number().gt(0).max(READ_ALOUD_MAX_SECONDS),
+    minSeconds: z9.number().min(0).optional(),
+    maxTakes: z9.number().int().min(1).max(READ_ALOUD_MAX_TAKES).optional()
+  }),
+  scoring: z9.strictObject({
+    dimensions: z9.array(
+      z9.strictObject({
+        name: z9.enum(READ_ALOUD_DIMENSIONS),
+        weight: z9.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/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 }) => ({
@@ -3717,11 +4235,48 @@ 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 = 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
+});
 registerActivityType(multipleChoiceType);
 registerActivityType(fillInTheBlanksType);
 registerActivityType(writtenResponseType);
 registerActivityType(gapSelectType);
 registerActivityType(dictationType);
+registerActivityType(readAloudType);
 
 export {
   ActivitySchemaError,
@@ -3734,6 +4289,8 @@ export {
   DICTATION_MAX_EQUIVALENCE_LENGTH,
   DICTATION_MAX_EQUIVALENCES,
   DICTATION_MAX_ACCEPTED_TRANSCRIPTS,
+  codePointLength,
+  normalizeDictationText,
   FeedbackSchema,
   MediaUrlSchema,
   NativeControlHintSchema,
@@ -3763,6 +4320,15 @@ export {
   MultipleChoiceOptionMediaSchema,
   MultipleChoiceOptionSchema,
   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,
+  ReadAloudSlowMediaSchema,
+  ReadAloudDataSchema,
   countWords,
   GapSelectChoiceSchema,
   GapSelectBankSchema,
@@ -3783,6 +4349,7 @@ export {
   RedactedWrittenResponseDataSchema,
   RedactedDictationSlowMediaSchema,
   RedactedDictationDataSchema,
+  RedactedReadAloudDataSchema,
   dictationReferenceWords,
   alignDictation,
   STEP,
@@ -3798,6 +4365,7 @@ export {
   fillInTheBlanksType,
   writtenResponseType,
   gapSelectType,
-  dictationType
+  dictationType,
+  readAloudType
 };
-//# sourceMappingURL=chunk-XKKKWKRH.js.map
+//# sourceMappingURL=chunk-6RND47QE.js.map