@intellectif/lk-core 0.22.0 → 1.0.0

package/dist/{chunk-D3GP5MET.js → chunk-FBKTION6.js}

@@ -1,29 +1,32 @@
-// src/schemas/ai.ts
+// src/schemas/media.ts
 import { z } from "zod/v4";
-var AiPermissionsSchema = z.looseObject({
-  explanations: z.boolean().optional(),
-  hints: z.boolean().optional()
-});
 
-// src/schemas/feedback.ts
-import { z as z2 } from "zod/v4";
-var FeedbackSchema = z2.looseObject({
-  correct: z2.string().min(1).optional(),
-  incorrect: z2.string().min(1).optional()
-});
+// 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
-import { z as z3 } from "zod/v4";
-var MediaUrlSchema = z3.union([
-  z3.url().refine((value) => /^(https?|data|blob):/i.test(value), {
+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."
   }),
-  z3.string().regex(/^\/(?!\/)\S*$/, {
+  z.string().regex(/^\/(?!\/)\S*$/, {
     error: 'Relative media URLs must be root-relative (a single leading "/").'
   })
 ]);
-var NativeControlHintSchema = z3.enum(["hide-download", "hide-rate"]);
-var MediaPlaybackSchema = z3.strictObject({
+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
@@ -31,29 +34,31 @@ var MediaPlaybackSchema = z3.strictObject({
    * play/pause, elapsed/total, mute, volume, optional speed, optional
    * scrubber, and a live plays-remaining status.
    */
-  controls: z3.enum(["native", "minimal"]).optional(),
+  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: z3.number().int().min(1).max(20).optional(),
+  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: z3.enum(["allow", "none"]).optional(),
+  seek: z.enum(["allow", "none"]).optional(),
   /** `fixed` renders no speed control and snaps `playbackRate` back to 1. */
-  rate: z3.enum(["allow", "fixed"]).optional(),
+  rate: z.enum(["allow", "fixed"]).optional(),
   /** Advisory only. See {@link NativeControlHintSchema}. */
-  nativeControlHints: z3.array(NativeControlHintSchema).min(1).max(2).optional()
+  nativeControlHints: z.array(NativeControlHintSchema).min(1).max(2).optional()
 });
-var MediaTrackSchema = z3.strictObject({
-  kind: z3.enum(["captions", "subtitles"]),
+var MediaTrackSchema = z.strictObject({
+  kind: z.enum(["captions", "subtitles"]),
   src: MediaUrlSchema,
-  srclang: z3.string().regex(/^[A-Za-z]{2,3}(-[A-Za-z0-9]{2,8})*$/, {
+  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: z3.string().max(60).refine((label) => label.trim().length > 0, { error: "A track label must not be empty." }),
-  default: z3.boolean().optional()
+  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) {
@@ -76,12 +81,12 @@ 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 = z3.looseObject({
-  type: z3.enum(["image", "audio", "video", "embed"]),
+var MediaSchema = z.looseObject({
+  type: z.enum(["image", "audio", "video", "embed"]),
   url: MediaUrlSchema,
-  alt: z3.string().min(1).optional(),
+  alt: z.string().min(1).optional(),
   captionsUrl: MediaUrlSchema.optional(),
-  tracks: z3.array(MediaTrackSchema).min(1).max(MAX_TRACKS).optional(),
+  tracks: z.array(MediaTrackSchema).min(1).max(MAX_TRACKS).optional(),
   poster: MediaUrlSchema.optional(),
   playback: MediaPlaybackSchema.optional()
 }).refine(
@@ -118,12 +123,12 @@ var MediaSchema = z3.looseObject({
     path: ["playback", "nativeControlHints"]
   }
 );
-var RedactedMediaSchema = z3.strictObject({
-  type: z3.enum(["image", "audio", "video", "embed"]),
+var RedactedMediaSchema = z.strictObject({
+  type: z.enum(["image", "audio", "video", "embed"]),
   url: MediaUrlSchema,
-  alt: z3.string().min(1).optional(),
+  alt: z.string().min(1).optional(),
   captionsUrl: MediaUrlSchema.optional(),
-  tracks: z3.array(MediaTrackSchema).min(1).max(MAX_TRACKS).optional(),
+  tracks: z.array(MediaTrackSchema).min(1).max(MAX_TRACKS).optional(),
   poster: MediaUrlSchema.optional(),
   playback: MediaPlaybackSchema.optional()
 }).refine(
@@ -137,70 +142,6 @@ var RedactedMediaSchema = z3.strictObject({
   path: ["url"]
 }).refine(posterFits, POSTER_FITS).refine(tracksFit, TRACKS_FIT).refine(tracksAreDistinct, TRACKS_DISTINCT);
 
-// src/schemas/fill-in-the-blanks.ts
-import { z as z4 } from "zod/v4";
-var PLACEHOLDER_RE = /\{\{\s*([^{}]+?)\s*\}\}/g;
-var TextMatchPolicySchema = z4.looseObject({
-  caseSensitive: z4.boolean().optional(),
-  trim: z4.boolean().optional(),
-  normalize: z4.enum(["none", "NFC", "NFKC"]).optional(),
-  foldDiacritics: z4.boolean().optional(),
-  collapseInnerWhitespace: z4.boolean().optional(),
-  ignorePunctuation: z4.boolean().optional(),
-  levenshtein: z4.number().int().min(0).optional(),
-  locale: z4.string().optional()
-});
-var BlankConfigSchema = z4.looseObject({
-  id: z4.string().min(1),
-  acceptedAnswers: z4.array(
-    z4.string().min(1).refine((answer) => answer.trim().length > 0, {
-      error: "Accepted answers must contain non-whitespace characters."
-    })
-  ).min(1),
-  caseSensitive: z4.boolean().optional(),
-  trimWhitespace: z4.boolean().optional(),
-  match: TextMatchPolicySchema.optional(),
-  hint: z4.string().optional(),
-  feedback: z4.string().optional()
-});
-var FillInTheBlanksDataSchema = z4.looseObject({
-  schemaVersion: z4.literal("1.0"),
-  type: z4.literal("fill-in-the-blanks"),
-  id: z4.string().min(1),
-  title: z4.string().min(1),
-  passage: z4.string().min(1),
-  passageHtml: z4.string().optional(),
-  blanks: z4.array(BlankConfigSchema).min(1),
-  scoringStrategy: z4.enum(["all-or-nothing", "partial"]),
-  media: MediaSchema.optional(),
-  feedback: FeedbackSchema.optional(),
-  passThreshold: z4.number().min(0).max(1).optional(),
-  locale: z4.string().optional(),
-  learningObjectives: z4.array(z4.string()).optional(),
-  difficultyLevel: z4.literal([1, 2, 3, 4, 5]).optional(),
-  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/validation-scope.ts
 var active = null;
 function withValidationScope(run) {
@@ -1306,791 +1247,182 @@ var DeferredScoringError = class extends Error {
   activityType;
 };
 
-// src/schemas/dictation.ts
-import { z as z5 } from "zod/v4";
-var DictationSlowMediaSchema = z5.looseObject({
-  type: z5.literal("audio"),
+// 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: z5.string().min(1).optional()
+  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 RuleTextSchema = z5.string().min(1).meta({ maxLength: DICTATION_MAX_EQUIVALENCE_LENGTH });
-var TranscriptTextSchema = z5.string().min(1).meta({ maxLength: DICTATION_MAX_TRANSCRIPT_LENGTH });
-var DictationEquivalenceSchema = z5.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 MultipleChoiceOptionSchema = z4.looseObject({
+  id: z4.string().min(1),
+  text: z4.string().min(1),
+  isCorrect: z4.boolean(),
+  feedback: z4.string().optional(),
+  media: MultipleChoiceOptionMediaSchema.optional()
 });
-var DictationToleranceSchema = z5.looseObject({
-  equivalences: z5.array(DictationEquivalenceSchema).max(DICTATION_MAX_EQUIVALENCES, {
-    error: `A dictation carries at most ${DICTATION_MAX_EQUIVALENCES} equivalence rules.`
-  }).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"]
 });
-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);
+
+// 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;
   }
-  return normalizer;
+  const trimmed = text.trim();
+  if (trimmed === "") {
+    return 0;
+  }
+  return trimmed.split(/\s+/).length;
 }
-function measure(data, text) {
-  return normalizerFor(data).measure(text);
+
+// src/schemas/read-schema.ts
+var OWN_SCHEMAS = /* @__PURE__ */ new WeakSet();
+function ownSchemas(...schemas) {
+  for (const schema of schemas) {
+    OWN_SCHEMAS.add(schema);
+  }
 }
-function candidatesOf(data) {
-  return [data.transcript, ...data.acceptedTranscripts ?? []];
+function isOwnSchema(schema) {
+  return OWN_SCHEMAS.has(schema);
 }
-function isEmpty(measured) {
-  return measured.normalized === "";
+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;
 }
-function checkEvenAfterIssues(check) {
-  const guard = new z5.core.$ZodCheck({ check: "custom", when: () => true });
-  guard._zod.check = check;
-  return guard;
+var isThenable = (value) => typeof value?.then === "function";
+function isZodSchema(schema) {
+  return schema["~standard"].vendor === "zod" && typeof schema.safeParse === "function";
 }
-var DictationDataShape = z5.looseObject({
-  schemaVersion: z5.literal("1.0"),
-  type: z5.literal("dictation"),
-  id: z5.string().min(1),
-  title: z5.string().min(1),
-  transcript: TranscriptTextSchema,
-  acceptedTranscripts: z5.array(TranscriptTextSchema).max(DICTATION_MAX_ACCEPTED_TRANSCRIPTS).optional(),
-  media: MediaSchema.optional(),
-  slowMedia: DictationSlowMediaSchema.optional(),
-  hints: z5.looseObject({ mode: z5.literal("progressive-words") }).optional(),
-  tolerance: DictationToleranceSchema.optional(),
-  feedback: FeedbackSchema.optional(),
-  passThreshold: z5.number().min(0).max(1).optional(),
-  locale: z5.string().optional(),
-  learningObjectives: z5.array(z5.string()).optional(),
-  difficultyLevel: z5.literal([1, 2, 3, 4, 5]).optional(),
-  ai: AiPermissionsSchema.optional()
-});
-var DictationDataSchema = DictationDataShape.check(
-  checkEvenAfterIssues((ctx) => {
-    if (ctx.issues.some((issue2) => (issue2.path?.length ?? 0) === 0)) {
-      return;
+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 };
     }
-    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] });
+    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 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)."
+  }
+  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
       );
-    }
-    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/schemas/multiple-choice.ts
-import { z as z6 } from "zod/v4";
-var MultipleChoiceOptionMediaSchema = z6.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: z6.enum(["image", "audio"]),
-  url: MediaUrlSchema,
-  alt: z6.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 = z6.looseObject({
-  id: z6.string().min(1),
-  text: z6.string().min(1),
-  isCorrect: z6.boolean(),
-  feedback: z6.string().optional(),
-  media: MultipleChoiceOptionMediaSchema.optional()
-});
-var MultipleChoiceDataSchema = z6.looseObject({
-  schemaVersion: z6.literal("1.0"),
-  type: z6.literal("multiple-choice"),
-  id: z6.string().min(1),
-  title: z6.string().min(1),
-  question: z6.string().min(1),
-  questionHtml: z6.string().optional(),
-  mode: z6.enum(["single", "multi"]),
-  options: z6.array(MultipleChoiceOptionSchema).min(2).max(26),
-  scoringStrategy: z6.enum(["all-or-nothing", "partial"]),
-  media: MediaSchema.optional(),
-  feedback: FeedbackSchema.optional(),
-  passThreshold: z6.number().min(0).max(1).optional(),
-  shuffle: z6.boolean().optional(),
-  locale: z6.string().optional(),
-  learningObjectives: z6.array(z6.string()).optional(),
-  difficultyLevel: z6.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/schemas/read-aloud.ts
-import { z as z7 } 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 = z7.strictObject({
-  type: z7.literal("audio"),
-  url: MediaUrlSchema,
-  alt: z7.string().min(1).optional()
-});
-var ReferenceTextSchema = z7.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 = z7.looseObject({
-  maxSeconds: z7.number().gt(0).max(READ_ALOUD_MAX_SECONDS),
-  minSeconds: z7.number().min(0).optional(),
-  maxTakes: z7.number().int().min(1).max(READ_ALOUD_MAX_TAKES).optional()
-});
-var ReadAloudDimensionWeightSchema = z7.looseObject({
-  name: z7.enum(READ_ALOUD_DIMENSIONS),
-  weight: z7.number().min(0).max(READ_ALOUD_MAX_DIMENSION_WEIGHT)
-});
-var ReadAloudScoringSchema = z7.looseObject({
-  dimensions: z7.array(ReadAloudDimensionWeightSchema).min(1).max(READ_ALOUD_MAX_DIMENSIONS)
-});
-function checkEvenAfterIssues2(check) {
-  const guard = new z7.core.$ZodCheck({ check: "custom", when: () => true });
-  guard._zod.check = check;
-  return guard;
-}
-var ReadAloudDataShape = z7.looseObject({
-  schemaVersion: z7.literal("1.0"),
-  type: z7.literal("read-aloud"),
-  id: z7.string().min(1),
-  title: z7.string().min(1),
-  instructions: z7.string().optional(),
-  referenceText: ReferenceTextSchema,
-  locale: z7.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: z7.number().min(0).max(1).optional(),
-  feedback: FeedbackSchema.optional(),
-  learningObjectives: z7.array(z7.string()).optional(),
-  difficultyLevel: z7.literal([1, 2, 3, 4, 5]).optional(),
-  ai: AiPermissionsSchema.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") {
-    return 0;
-  }
-  const trimmed = text.trim();
-  if (trimmed === "") {
-    return 0;
-  }
-  return trimmed.split(/\s+/).length;
-}
-
-// src/schemas/gap-select.ts
-import { z as z8 } from "zod/v4";
-var GapSelectChoiceSchema = z8.looseObject({
-  id: z8.string().min(1),
-  text: z8.string().min(1)
-});
-var GapSelectBankSchema = z8.looseObject({
-  id: z8.string().min(1),
-  choices: z8.array(GapSelectChoiceSchema).min(2)
-});
-var GapSelectGapSchema = z8.looseObject({
-  id: z8.string().min(1),
-  choices: z8.array(GapSelectChoiceSchema).min(2).optional(),
-  bankId: z8.string().min(1).optional(),
-  correctChoiceId: z8.string().min(1),
-  feedback: z8.string().optional()
-});
-function resolveChoices(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 = z8.looseObject({
-  schemaVersion: z8.literal("1.0"),
-  type: z8.literal("gap-select"),
-  id: z8.string().min(1),
-  title: z8.string().min(1),
-  passage: z8.string().min(1),
-  passageHtml: z8.string().optional(),
-  gaps: z8.array(GapSelectGapSchema).min(1),
-  banks: z8.array(GapSelectBankSchema).optional(),
-  scoringStrategy: z8.enum(["all-or-nothing", "partial"]),
-  presentation: z8.literal("dropdown").optional(),
-  shuffleChoices: z8.boolean().optional(),
-  media: MediaSchema.optional(),
-  feedback: FeedbackSchema.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(),
-  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 = resolveChoices(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/written-response.ts
-import { z as z9 } from "zod/v4";
-var WrittenResponseRubricCriterionSchema = z9.looseObject({
-  name: z9.string().min(1),
-  description: z9.string().optional(),
-  weight: z9.number().min(0)
-});
-var WrittenResponseRubricSchema = z9.looseObject({
-  label: z9.string().optional(),
-  criteria: z9.array(WrittenResponseRubricCriterionSchema).min(1)
-});
-var RedactedWrittenResponseRubricCriterionSchema = z9.strictObject({
-  name: z9.string().min(1),
-  description: z9.string().optional(),
-  weight: z9.number().min(0)
-});
-var RedactedWrittenResponseRubricSchema = z9.strictObject({
-  label: z9.string().optional(),
-  criteria: z9.array(RedactedWrittenResponseRubricCriterionSchema).min(1)
-});
-var WrittenResponseDataSchema = z9.looseObject({
-  schemaVersion: z9.literal("1.0"),
-  type: z9.literal("written-response"),
-  id: z9.string().min(1),
-  title: z9.string().min(1),
-  prompt: z9.string(),
-  promptHtml: z9.string().optional(),
-  minWords: z9.number().int().min(0),
-  maxWords: z9.number().int().min(1),
-  rubric: WrittenResponseRubricSchema.optional(),
-  languageTarget: z9.string().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) => data.maxWords >= data.minWords, {
-  error: "maxWords must be greater than or equal to minWords.",
-  path: ["maxWords"]
-});
-
-// src/schemas/redacted.ts
-import { z as z10 } from "zod/v4";
-var redactedBase = {
-  /** Marker distinguishing a redacted projection from full activity data. */
-  redacted: z10.literal(true),
-  /** Slot identity, carried through redaction so the client and the plan agree. */
-  slotKey: z10.string().min(1).optional(),
-  schemaVersion: z10.literal("1.0"),
-  id: z10.string().min(1),
-  title: z10.string().min(1),
-  media: RedactedMediaSchema.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: z10.strictObject({ explanations: z10.boolean().optional(), hints: z10.boolean().optional() }).optional()
-};
-var RedactedMultipleChoiceOptionMediaSchema = z10.strictObject({
-  type: z10.enum(["image", "audio"]),
-  url: z10.string().min(1),
-  alt: z10.string().min(1).optional(),
-  captionsUrl: z10.string().min(1).optional()
-});
-var RedactedMultipleChoiceOptionSchema = z10.strictObject({
-  id: z10.string().min(1),
-  text: z10.string().min(1),
-  media: RedactedMultipleChoiceOptionMediaSchema.optional()
-});
-var RedactedMultipleChoiceDataSchema = z10.strictObject({
-  ...redactedBase,
-  type: z10.literal("multiple-choice"),
-  question: z10.string().min(1),
-  questionHtml: z10.string().optional(),
-  mode: z10.enum(["single", "multi"]),
-  options: z10.array(RedactedMultipleChoiceOptionSchema).min(2).max(26),
-  shuffle: z10.boolean().optional()
-});
-var RedactedBlankConfigSchema = z10.strictObject({
-  id: z10.string().min(1),
-  hint: z10.string().optional()
-});
-var RedactedFillInTheBlanksDataSchema = z10.strictObject({
-  ...redactedBase,
-  type: z10.literal("fill-in-the-blanks"),
-  passage: z10.string().min(1),
-  passageHtml: z10.string().optional(),
-  blanks: z10.array(RedactedBlankConfigSchema).min(1)
-});
-var RedactedGapSelectChoiceSchema = z10.strictObject({
-  id: z10.string().min(1),
-  text: z10.string().min(1)
-});
-var RedactedGapSelectBankSchema = z10.strictObject({
-  id: z10.string().min(1),
-  choices: z10.array(RedactedGapSelectChoiceSchema).min(2)
-});
-var RedactedGapSelectGapSchema = z10.strictObject({
-  id: z10.string().min(1),
-  choices: z10.array(RedactedGapSelectChoiceSchema).min(2).optional(),
-  bankId: z10.string().min(1).optional()
-});
-var RedactedGapSelectDataSchema = z10.strictObject({
-  ...redactedBase,
-  type: z10.literal("gap-select"),
-  passage: z10.string().min(1),
-  passageHtml: z10.string().optional(),
-  gaps: z10.array(RedactedGapSelectGapSchema).min(1),
-  banks: z10.array(RedactedGapSelectBankSchema).optional(),
-  presentation: z10.literal("dropdown").optional(),
-  shuffleChoices: z10.boolean().optional()
-});
-var RedactedWrittenResponseDataSchema = z10.strictObject({
-  ...redactedBase,
-  type: z10.literal("written-response"),
-  prompt: z10.string(),
-  promptHtml: z10.string().optional(),
-  minWords: z10.number().int().min(0),
-  maxWords: z10.number().int().min(1),
-  rubric: RedactedWrittenResponseRubricSchema.optional(),
-  languageTarget: z10.string().optional()
-});
-var RedactedDictationSlowMediaSchema = z10.strictObject({
-  type: z10.literal("audio"),
-  url: MediaUrlSchema,
-  alt: z10.string().min(1).optional()
-});
-var RedactedDictationDataSchema = z10.strictObject({
-  ...redactedBase,
-  type: z10.literal("dictation"),
-  slowMedia: RedactedDictationSlowMediaSchema.optional(),
-  hints: z10.strictObject({ mode: z10.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 = z10.strictObject({
-  ...redactedBase,
-  type: z10.literal("read-aloud"),
-  locale: z10.string().regex(CANONICAL_LOCALE_RE),
-  instructions: z10.string().optional(),
-  referenceText: z10.string().min(1),
-  slowMedia: ReadAloudSlowMediaSchema.optional(),
-  recording: z10.strictObject({
-    maxSeconds: z10.number().gt(0).max(READ_ALOUD_MAX_SECONDS),
-    minSeconds: z10.number().min(0).optional(),
-    maxTakes: z10.number().int().min(1).max(READ_ALOUD_MAX_TAKES).optional()
-  }),
-  scoring: z10.strictObject({
-    dimensions: z10.array(
-      z10.strictObject({
-        name: z10.enum(READ_ALOUD_DIMENSIONS),
-        weight: z10.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"]
-    });
+      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;
@@ -2143,66 +1475,326 @@ function levenshteinDistance(a, b, max) {
       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" };
+    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 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 fields = [];
+  if (written(media.captionsUrl)) {
+    fields.push("captionsUrl");
   }
-  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" };
+  if (Array.isArray(media.tracks) && media.tracks.length > 0) {
+    fields.push("tracks");
   }
-  return { matched: false, via: "none" };
-}
-
-// src/registry/registry.ts
-var registry = /* @__PURE__ */ new Map();
-function defineActivityType(descriptor) {
-  return descriptor;
+  return fields;
 }
-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.`
-    );
+function groupCaptionsField(group, written) {
+  if (!isObject(group) || !isObject(group.stimulus) || !Array.isArray(group.items)) {
+    return void 0;
   }
-  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.`
-    );
+  const [field] = captionFieldsOf(group.stimulus.media, written);
+  if (field === void 0) {
+    return void 0;
   }
-  registry.set(descriptor.type, descriptor);
-}
-function getActivityTypeDescriptor(type) {
-  return registry.get(type);
-}
-function registeredActivityTypes() {
-  return [...registry.keys()];
+  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 = {
@@ -2365,7 +1957,7 @@ function issue(code, path, message) {
 function isRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-function valueAt(root, path) {
+function valueAt2(root, path) {
   let node = root;
   for (const segment of path) {
     if (typeof node !== "object" || node === null) {
@@ -2377,9 +1969,9 @@ function valueAt(root, path) {
 }
 function refusesEmpty(root, schemaIssue) {
   const { path } = schemaIssue;
-  const value = valueAt(root, path);
+  const value = valueAt2(root, path);
   const index = path.at(-1);
-  const list = valueAt(root, path.slice(0, -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");
 }
@@ -2906,6 +2498,70 @@ function checkTolerance(tolerance) {
   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 }) => ({
@@ -3262,7 +2918,7 @@ function checkAnswerKey(gap, index, name, banks, bankIds) {
   if (typeof key !== "string") {
     return [];
   }
-  const choices = resolveChoices2(gap, banks, bankIds);
+  const choices = resolveChoices(gap, banks, bankIds);
   if (choices === void 0) {
     return [];
   }
@@ -3275,7 +2931,7 @@ function checkAnswerKey(gap, index, name, banks, bankIds) {
     )
   ];
 }
-function resolveChoices2(gap, banks, bankIds) {
+function resolveChoices(gap, banks, bankIds) {
   const hasOwn = !isUnset(gap.choices);
   const hasBank = !isUnwritten(gap.bankId);
   if (hasOwn === hasBank) {
@@ -3499,24 +3155,173 @@ function checkMultipleChoiceDraft(draft) {
         )
       );
     }
-  }
-  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);
-}
+  }
+  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 = {
@@ -3936,6 +3741,330 @@ function checkCriteria(criteria) {
   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 : "");
@@ -3946,7 +4075,6 @@ function scoreDictation(data, response) {
     }
     details.push({
       itemId: word.itemId,
-      correct: word.status === "correct",
       outcome: word.status === "correct" ? "correct" : word.status === "incorrect" ? "incorrect" : "incorrect-omission",
       learnerResponse: word.attempt,
       correctResponse: word.reference,
@@ -3990,7 +4118,6 @@ function scoreFillInTheBlanks(data, response) {
     perBlankCorrect.push(matched);
     details.push({
       itemId: blank.id,
-      correct: matched,
       outcome: matched ? "correct" : "incorrect",
       learnerResponse: [input],
       correctResponse: [...blank.acceptedAnswers],
@@ -4022,7 +4149,6 @@ function scoreGapSelect(data, response) {
     perGapCorrect.push(correct);
     details.push({
       itemId: gap.id,
-      correct,
       outcome: correct ? "correct" : answered ? "incorrect" : "incorrect-omission",
       learnerResponse: [selected],
       correctResponse: [gap.correctChoiceId],
@@ -4067,7 +4193,6 @@ function scoreMultipleChoice(data, response) {
     const outcome = wasSelected ? option.isCorrect ? "correct" : "incorrect" : option.isCorrect ? "incorrect-omission" : "correct-omission";
     return {
       itemId: option.id,
-      correct: wasSelected === option.isCorrect,
       outcome,
       learnerResponse: [wasSelected ? "selected" : "not-selected"],
       correctResponse: [option.isCorrect ? "selected" : "not-selected"],
@@ -4383,6 +4508,19 @@ var readAloudType = defineActivityType({
   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);
@@ -4391,17 +4529,10 @@ registerActivityType(dictationType);
 registerActivityType(readAloudType);
 
 export {
-  AiPermissionsSchema,
-  FeedbackSchema,
-  MediaUrlSchema,
-  NativeControlHintSchema,
-  MediaPlaybackSchema,
-  MediaTrackSchema,
+  maxUnits,
   MediaSchema,
   RedactedMediaSchema,
   PLACEHOLDER_RE,
-  TextMatchPolicySchema,
-  BlankConfigSchema,
   FillInTheBlanksDataSchema,
   withValidationScope,
   DICTATION_MAX_TRANSCRIPT_LENGTH,
@@ -4419,9 +4550,6 @@ export {
   UnknownActivityTypeError,
   RedactedScoringError,
   DeferredScoringError,
-  DictationSlowMediaSchema,
-  DictationEquivalenceSchema,
-  DictationToleranceSchema,
   DictationDataSchema,
   groupCaptionsField,
   GROUP_CAPTIONS_REVEAL_DICTATION,
@@ -4437,7 +4565,6 @@ export {
   pathKey,
   coveredPathsOf,
   MultipleChoiceOptionMediaSchema,
-  MultipleChoiceOptionSchema,
   MultipleChoiceDataSchema,
   READ_ALOUD_MAX_REFERENCE_LENGTH,
   READ_ALOUD_MAX_SECONDS,
@@ -4446,29 +4573,13 @@ export {
   SPEECH_ASSESSMENT_MAX_WORDS,
   SPEECH_ASSESSMENT_MAX_TEXT_LENGTH,
   CANONICAL_LOCALE_RE,
-  ReadAloudSlowMediaSchema,
   ReadAloudDataSchema,
   countWords,
-  GapSelectChoiceSchema,
-  GapSelectBankSchema,
-  GapSelectGapSchema,
   GapSelectDataSchema,
-  WrittenResponseRubricCriterionSchema,
-  WrittenResponseRubricSchema,
+  isOwnSchema,
+  readSchema,
+  standardJsonSchemaOf,
   WrittenResponseDataSchema,
-  RedactedMultipleChoiceOptionMediaSchema,
-  RedactedMultipleChoiceOptionSchema,
-  RedactedMultipleChoiceDataSchema,
-  RedactedBlankConfigSchema,
-  RedactedFillInTheBlanksDataSchema,
-  RedactedGapSelectChoiceSchema,
-  RedactedGapSelectBankSchema,
-  RedactedGapSelectGapSchema,
-  RedactedGapSelectDataSchema,
-  RedactedWrittenResponseDataSchema,
-  RedactedDictationSlowMediaSchema,
-  RedactedDictationDataSchema,
-  RedactedReadAloudDataSchema,
   levenshteinDistance,
   matchText,
   defineActivityType,
@@ -4483,4 +4594,4 @@ export {
   dictationType,
   readAloudType
 };
-//# sourceMappingURL=chunk-D3GP5MET.js.map
+//# sourceMappingURL=chunk-FBKTION6.js.map