@intellectif/lk-core 0.15.0 → 0.17.0

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

@@ -1,42 +1,205 @@
-// src/errors.ts
-var ActivitySchemaError = class extends Error {
-  constructor(activityType, errors) {
-    super(`Invalid activity data for type "${activityType}"`);
-    this.activityType = activityType;
-    this.errors = errors;
-    this.name = "ActivitySchemaError";
+// src/schemas/ai.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/media.ts
+import { z as z3 } from "zod/v4";
+var MediaUrlSchema = z3.union([
+  z3.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*$/, {
+    error: 'Relative media URLs must be root-relative (a single leading "/").'
+  })
+]);
+var NativeControlHintSchema = z3.enum(["hide-download", "hide-rate"]);
+var MediaPlaybackSchema = z3.strictObject({
+  /**
+   * `native` (the resolved default) renders today's `<audio controls>`
+   * unchanged. `minimal` — resolved automatically whenever any enforcement
+   * field is set — replaces the browser bar with the SDK transport:
+   * play/pause, elapsed/total, mute, volume, optional speed, optional
+   * scrubber, and a live plays-remaining status.
+   */
+  controls: z3.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(),
+  /** `none` renders no scrubber and reverts an out-of-band seek to the high-water mark. */
+  seek: z3.enum(["allow", "none"]).optional(),
+  /** `fixed` renders no speed control and snaps `playbackRate` back to 1. */
+  rate: z3.enum(["allow", "fixed"]).optional(),
+  /** Advisory only. See {@link NativeControlHintSchema}. */
+  nativeControlHints: z3.array(NativeControlHintSchema).min(1).max(2).optional()
+});
+var MediaTrackSchema = z3.strictObject({
+  kind: z3.enum(["captions", "subtitles"]),
+  src: MediaUrlSchema,
+  srclang: z3.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()
+});
+var MAX_TRACKS = 12;
+function posterFits(m) {
+  return m.poster === void 0 || m.type === "video";
+}
+function tracksFit(m) {
+  return m.tracks === void 0 || m.type === "audio" || m.type === "video";
+}
+function tracksAreDistinct(m) {
+  if (m.tracks === void 0) {
+    return true;
   }
-  activityType;
-  errors;
+  const defaults = m.tracks.filter((track) => track.default === true).length;
+  const keys = new Set(m.tracks.map((track) => `${track.kind}:${track.srclang.toLowerCase()}`));
+  return defaults <= 1 && keys.size === m.tracks.length;
+}
+var POSTER_FITS = { error: "poster is for video media only.", path: ["poster"] };
+var TRACKS_FIT = { error: "tracks are for audio and video media only.", path: ["tracks"] };
+var TRACKS_DISTINCT = {
+  error: "tracks: at most one may be the default, and no two may share a kind and a language \u2014 a menu listing one language twice cannot say which one it plays.",
+  path: ["tracks"]
 };
-var UnknownActivityTypeError = class extends Error {
-  constructor(activityType) {
-    super(`Activity type "${activityType}" is not registered`);
-    this.activityType = activityType;
-    this.name = "UnknownActivityTypeError";
+var MediaSchema = z3.looseObject({
+  type: z3.enum(["image", "audio", "video", "embed"]),
+  url: MediaUrlSchema,
+  alt: z3.string().min(1).optional(),
+  captionsUrl: MediaUrlSchema.optional(),
+  tracks: z3.array(MediaTrackSchema).min(1).max(MAX_TRACKS).optional(),
+  poster: MediaUrlSchema.optional(),
+  playback: MediaPlaybackSchema.optional()
+}).refine(
+  (m) => m.type !== "image" && m.type !== "embed" || typeof m.alt === "string" && m.alt.length > 0,
+  {
+    error: "image and embed media require non-empty alt text (WCAG 1.1.1 / 4.1.2).",
+    path: ["alt"]
   }
-  activityType;
-};
-var RedactedScoringError = class extends Error {
-  constructor(activityType) {
-    super(
-      `Activity data for "${activityType}" carries no answer key (it looks redacted), so it cannot be scored. Score against the full activity data server-side. evaluate() answers this input without throwing, but it never grades it.`
-    );
-    this.activityType = activityType;
-    this.name = "RedactedScoringError";
+).refine((m) => m.type !== "embed" || /^https?:\/\//i.test(m.url), {
+  error: "embed media requires an absolute http(s) provider URL. data:, blob:, and relative URLs are not allowed for embeds \u2014 the embed iframe runs with allow-scripts, and a data:/same-origin document there is an XSS vector.",
+  path: ["url"]
+}).refine(posterFits, POSTER_FITS).refine(tracksFit, TRACKS_FIT).refine(tracksAreDistinct, TRACKS_DISTINCT).refine((m) => m.playback === void 0 || m.type === "audio", {
+  error: "playback policy is supported on audio media only. An embed is a provider iframe the SDK cannot control at all (it has no reliable JS API for a third-party player); an image has nothing to play; video is deliberately deferred, because a video transport must also own fullscreen and Picture-in-Picture and the SDK will not pretend to govern those yet.",
+  path: ["playback"]
+}).refine(
+  (m) => m.playback?.controls !== "native" || m.playback.maxPlays === void 0 && m.playback.seek !== "none" && m.playback.rate !== "fixed",
+  {
+    error: 'controls: "native" cannot carry maxPlays, seek: "none" or rate: "fixed". The browser\'s own bar keeps its play button enabled after a budget is spent, and keeps a scrubber that would move and then silently snap back \u2014 a control that looks operable and does nothing (WCAG 3.2.2 / 4.1.3). Omit `controls` and the SDK transport is used automatically, or use nativeControlHints for a cosmetic hint.',
+    path: ["playback", "controls"]
   }
-  activityType;
-};
-var DeferredScoringError = class extends Error {
-  constructor(activityType) {
-    super(
-      `Activity type "${activityType}" is graded asynchronously and has no synchronous score. Use evaluate() \u2014 it returns { status: 'deferred' } for this type.`
-    );
-    this.activityType = activityType;
-    this.name = "DeferredScoringError";
+).refine((m) => m.playback?.maxPlays === void 0 || m.playback.seek !== "allow", {
+  error: 'maxPlays cannot be combined with seek: "allow". A play is consumed when playback starts from somewhere other than where it stopped, so scrubbing back mid-play would replay the whole recording without spending anything. Omit `seek` \u2014 it resolves to "none" under a budget.',
+  path: ["playback", "seek"]
+}).refine(
+  (m) => m.playback?.controls !== "minimal" || m.playback.maxPlays !== void 0 || m.playback.seek === "none" || m.playback.rate === "fixed",
+  {
+    error: 'controls: "minimal" with nothing to enforce trades the browser\'s localized, familiar control bar for the SDK\'s, and buys nothing. Set maxPlays, seek: "none" or rate: "fixed", or omit `controls`.',
+    path: ["playback", "controls"]
   }
-  activityType;
-};
+).refine(
+  (m) => m.playback?.nativeControlHints === void 0 || m.playback.controls !== "minimal" && m.playback.maxPlays === void 0 && m.playback.seek !== "none" && m.playback.rate !== "fixed",
+  {
+    error: "nativeControlHints only affects the browser's own control bar, and an enforcing policy replaces that bar with the SDK transport \u2014 so the hints would be silently inert. Use them on an otherwise unrestricted recording, or drop them.",
+    path: ["playback", "nativeControlHints"]
+  }
+);
+var RedactedMediaSchema = z3.strictObject({
+  type: z3.enum(["image", "audio", "video", "embed"]),
+  url: MediaUrlSchema,
+  alt: z3.string().min(1).optional(),
+  captionsUrl: MediaUrlSchema.optional(),
+  tracks: z3.array(MediaTrackSchema).min(1).max(MAX_TRACKS).optional(),
+  poster: MediaUrlSchema.optional(),
+  playback: MediaPlaybackSchema.optional()
+}).refine(
+  (m) => m.type !== "image" && m.type !== "embed" || typeof m.alt === "string" && m.alt.length > 0,
+  {
+    error: "image and embed media require non-empty alt text (WCAG 1.1.1 / 4.1.2).",
+    path: ["alt"]
+  }
+).refine((m) => m.type !== "embed" || /^https?:\/\//i.test(m.url), {
+  error: "embed media requires an absolute http(s) provider URL. data:, blob:, and relative URLs are not allowed for embeds \u2014 the embed iframe runs with allow-scripts, and a data:/same-origin document there is an XSS vector.",
+  path: ["url"]
+}).refine(posterFits, POSTER_FITS).refine(tracksFit, TRACKS_FIT).refine(tracksAreDistinct, TRACKS_DISTINCT);
+
+// src/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;
@@ -912,148 +1075,247 @@ function searchReveal(forms, candidate) {
   });
 }
 
-// src/schemas/feedback.ts
-import { z } from "zod/v4";
-var FeedbackSchema = z.looseObject({
-  correct: z.string().min(1).optional(),
-  incorrect: z.string().min(1).optional()
-});
-
-// src/schemas/media.ts
-import { z as z2 } from "zod/v4";
-var MediaUrlSchema = z2.union([
-  z2.url().refine((value) => /^(https?|data|blob):/i.test(value), {
-    error: "Absolute media URLs must use the https:, http:, data:, or blob: scheme."
-  }),
-  z2.string().regex(/^\/(?!\/)\S*$/, {
-    error: 'Relative media URLs must be root-relative (a single leading "/").'
-  })
-]);
-var NativeControlHintSchema = z2.enum(["hide-download", "hide-rate"]);
-var MediaPlaybackSchema = z2.strictObject({
-  /**
-   * `native` (the resolved default) renders today's `<audio controls>`
-   * unchanged. `minimal` — resolved automatically whenever any enforcement
-   * field is set — replaces the browser bar with the SDK transport:
-   * play/pause, elapsed/total, mute, volume, optional speed, optional
-   * scrubber, and a live plays-remaining status.
-   */
-  controls: z2.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: z2.number().int().min(1).max(20).optional(),
-  /** `none` renders no scrubber and reverts an out-of-band seek to the high-water mark. */
-  seek: z2.enum(["allow", "none"]).optional(),
-  /** `fixed` renders no speed control and snaps `playbackRate` back to 1. */
-  rate: z2.enum(["allow", "fixed"]).optional(),
-  /** Advisory only. See {@link NativeControlHintSchema}. */
-  nativeControlHints: z2.array(NativeControlHintSchema).min(1).max(2).optional()
-});
-var MediaTrackSchema = z2.strictObject({
-  kind: z2.enum(["captions", "subtitles"]),
-  src: MediaUrlSchema,
-  srclang: z2.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: z2.string().max(60).refine((label) => label.trim().length > 0, { error: "A track label must not be empty." }),
-  default: z2.boolean().optional()
-});
-var MAX_TRACKS = 12;
-function posterFits(m) {
-  return m.poster === void 0 || m.type === "video";
-}
-function tracksFit(m) {
-  return m.tracks === void 0 || m.type === "audio" || m.type === "video";
+// src/scoring/dictation/edit-distance.ts
+function codePoints(text) {
+  return Array.from(text, (character) => character.codePointAt(0));
 }
-function tracksAreDistinct(m) {
-  if (m.tracks === void 0) {
-    return true;
+function editDistance(a, b) {
+  if (a === b) {
+    return 0;
   }
-  const defaults = m.tracks.filter((track) => track.default === true).length;
-  const keys = new Set(m.tracks.map((track) => `${track.kind}:${track.srclang.toLowerCase()}`));
-  return defaults <= 1 && keys.size === m.tracks.length;
-}
-var POSTER_FITS = { error: "poster is for video media only.", path: ["poster"] };
-var TRACKS_FIT = { error: "tracks are for audio and video media only.", path: ["tracks"] };
-var TRACKS_DISTINCT = {
-  error: "tracks: at most one may be the default, and no two may share a kind and a language \u2014 a menu listing one language twice cannot say which one it plays.",
-  path: ["tracks"]
-};
-var MediaSchema = z2.looseObject({
-  type: z2.enum(["image", "audio", "video", "embed"]),
-  url: MediaUrlSchema,
-  alt: z2.string().min(1).optional(),
-  captionsUrl: MediaUrlSchema.optional(),
-  tracks: z2.array(MediaTrackSchema).min(1).max(MAX_TRACKS).optional(),
-  poster: MediaUrlSchema.optional(),
-  playback: MediaPlaybackSchema.optional()
-}).refine(
-  (m) => m.type !== "image" && m.type !== "embed" || typeof m.alt === "string" && m.alt.length > 0,
-  {
-    error: "image and embed media require non-empty alt text (WCAG 1.1.1 / 4.1.2).",
-    path: ["alt"]
+  let left = codePoints(a);
+  let right = codePoints(b);
+  if (left.length < right.length) {
+    [left, right] = [right, left];
   }
-).refine((m) => m.type !== "embed" || /^https?:\/\//i.test(m.url), {
-  error: "embed media requires an absolute http(s) provider URL. data:, blob:, and relative URLs are not allowed for embeds \u2014 the embed iframe runs with allow-scripts, and a data:/same-origin document there is an XSS vector.",
-  path: ["url"]
-}).refine(posterFits, POSTER_FITS).refine(tracksFit, TRACKS_FIT).refine(tracksAreDistinct, TRACKS_DISTINCT).refine((m) => m.playback === void 0 || m.type === "audio", {
-  error: "playback policy is supported on audio media only. An embed is a provider iframe the SDK cannot control at all (it has no reliable JS API for a third-party player); an image has nothing to play; video is deliberately deferred, because a video transport must also own fullscreen and Picture-in-Picture and the SDK will not pretend to govern those yet.",
-  path: ["playback"]
-}).refine(
-  (m) => m.playback?.controls !== "native" || m.playback.maxPlays === void 0 && m.playback.seek !== "none" && m.playback.rate !== "fixed",
-  {
-    error: 'controls: "native" cannot carry maxPlays, seek: "none" or rate: "fixed". The browser\'s own bar keeps its play button enabled after a budget is spent, and keeps a scrubber that would move and then silently snap back \u2014 a control that looks operable and does nothing (WCAG 3.2.2 / 4.1.3). Omit `controls` and the SDK transport is used automatically, or use nativeControlHints for a cosmetic hint.',
-    path: ["playback", "controls"]
+  if (right.length === 0) {
+    return left.length;
   }
-).refine((m) => m.playback?.maxPlays === void 0 || m.playback.seek !== "allow", {
-  error: 'maxPlays cannot be combined with seek: "allow". A play is consumed when playback starts from somewhere other than where it stopped, so scrubbing back mid-play would replay the whole recording without spending anything. Omit `seek` \u2014 it resolves to "none" under a budget.',
-  path: ["playback", "seek"]
-}).refine(
-  (m) => m.playback?.controls !== "minimal" || m.playback.maxPlays !== void 0 || m.playback.seek === "none" || m.playback.rate === "fixed",
-  {
-    error: 'controls: "minimal" with nothing to enforce trades the browser\'s localized, familiar control bar for the SDK\'s, and buys nothing. Set maxPlays, seek: "none" or rate: "fixed", or omit `controls`.',
-    path: ["playback", "controls"]
+  let previous = new Uint32Array(right.length + 1);
+  let current = new Uint32Array(right.length + 1);
+  for (let j = 0; j <= right.length; j += 1) {
+    previous[j] = j;
   }
-).refine(
-  (m) => m.playback?.nativeControlHints === void 0 || m.playback.controls !== "minimal" && m.playback.maxPlays === void 0 && m.playback.seek !== "none" && m.playback.rate !== "fixed",
-  {
-    error: "nativeControlHints only affects the browser's own control bar, and an enforcing policy replaces that bar with the SDK transport \u2014 so the hints would be silently inert. Use them on an otherwise unrestricted recording, or drop them.",
-    path: ["playback", "nativeControlHints"]
+  for (let i = 1; i <= left.length; i += 1) {
+    current[0] = i;
+    const leftPoint = left[i - 1];
+    for (let j = 1; j <= right.length; j += 1) {
+      const deletion = previous[j] + 1;
+      const insertion = current[j - 1] + 1;
+      const substitution = previous[j - 1] + (leftPoint === right[j - 1] ? 0 : 1);
+      current[j] = Math.min(deletion, insertion, substitution);
+    }
+    [previous, current] = [current, previous];
   }
-);
-var RedactedMediaSchema = z2.strictObject({
-  type: z2.enum(["image", "audio", "video", "embed"]),
-  url: MediaUrlSchema,
-  alt: z2.string().min(1).optional(),
-  captionsUrl: MediaUrlSchema.optional(),
-  tracks: z2.array(MediaTrackSchema).min(1).max(MAX_TRACKS).optional(),
-  poster: MediaUrlSchema.optional(),
-  playback: MediaPlaybackSchema.optional()
-}).refine(
-  (m) => m.type !== "image" && m.type !== "embed" || typeof m.alt === "string" && m.alt.length > 0,
-  {
-    error: "image and embed media require non-empty alt text (WCAG 1.1.1 / 4.1.2).",
-    path: ["alt"]
+  return previous[right.length];
+}
+function similarity(a, b) {
+  const max = Math.max(codePoints(a).length, codePoints(b).length);
+  return max === 0 ? 0 : (max - editDistance(a, b)) / max;
+}
+
+// src/scoring/dictation/align.ts
+function dictationReferenceWords(data) {
+  return rawCandidates(data).map(
+    (candidate) => tokensOf(normalizeCandidate(candidate, data)).map((word, index) => ({
+      itemId: `w${index + 1}`,
+      word
+    }))
+  );
+}
+function alignDictation(data, text) {
+  const raw = typeof text === "string" ? text : "";
+  const capped = truncateCodePoints(raw, DICTATION_MAX_TEXT_LENGTH);
+  const { text: normalized, cut } = normalizeDictationTextBounded(capped, data.tolerance);
+  const attempt = cutAt(normalized, DICTATION_MAX_TEXT_LENGTH);
+  const truncated = cut || capped.length < raw.length || attempt.length < normalized.length;
+  const candidates = [];
+  rawCandidates(data).forEach((candidate, index) => {
+    const candidateText = normalizeCandidate(candidate, data);
+    if (candidateText !== "") {
+      candidates.push({ index, text: candidateText });
+    }
+  });
+  if (candidates.length === 0) {
+    return { candidateIndex: -1, reference: "", attempt, truncated, similarity: 0, words: [] };
   }
-).refine((m) => m.type !== "embed" || /^https?:\/\//i.test(m.url), {
-  error: "embed media requires an absolute http(s) provider URL. data:, blob:, and relative URLs are not allowed for embeds \u2014 the embed iframe runs with allow-scripts, and a data:/same-origin document there is an XSS vector.",
-  path: ["url"]
-}).refine(posterFits, POSTER_FITS).refine(tracksFit, TRACKS_FIT).refine(tracksAreDistinct, TRACKS_DISTINCT);
+  let chosen = candidates[0];
+  let best = similarity(chosen.text, attempt);
+  for (const candidate of candidates.slice(1)) {
+    const candidateSimilarity = similarity(candidate.text, attempt);
+    if (candidateSimilarity > best) {
+      best = candidateSimilarity;
+      chosen = candidate;
+    }
+  }
+  return {
+    candidateIndex: chosen.index,
+    reference: chosen.text,
+    attempt,
+    truncated,
+    similarity: best,
+    words: alignWords(tokensOf(chosen.text), tokensOf(attempt))
+  };
+}
+function rawCandidates(data) {
+  return [
+    data.transcript,
+    ...Array.isArray(data.acceptedTranscripts) ? data.acceptedTranscripts.slice(0, DICTATION_MAX_ACCEPTED_TRANSCRIPTS) : []
+  ];
+}
+function normalizeCandidate(candidate, data) {
+  return typeof candidate === "string" ? cutAt(
+    normalizeDictationText(
+      truncateCodePoints(candidate, DICTATION_MAX_TRANSCRIPT_LENGTH),
+      data.tolerance
+    ),
+    DICTATION_MAX_TRANSCRIPT_LENGTH
+  ) : "";
+}
+function cutAt(normalized, max) {
+  const cut = truncateCodePoints(normalized, max);
+  return cut.endsWith(" ") ? cut.slice(0, -1) : cut;
+}
+function tokensOf(normalized) {
+  return normalized === "" ? [] : normalized.split(" ");
+}
+var STEP = {
+  /** A reference element paired with an attempt element — equal or substituted. */
+  pair: 0,
+  /** A reference element the attempt lacks. */
+  missing: 1,
+  /** An attempt element the reference lacks. */
+  extra: 2
+};
+function alignSequences(reference, attempt) {
+  const rows = reference.length;
+  const columns = attempt.length;
+  const width = columns + 1;
+  const steps = new Uint8Array((rows + 1) * width);
+  let previous = new Uint32Array(width);
+  let current = new Uint32Array(width);
+  for (let j2 = 0; j2 <= columns; j2 += 1) {
+    previous[j2] = j2;
+    steps[j2] = STEP.extra;
+  }
+  for (let i2 = 1; i2 <= rows; i2 += 1) {
+    current[0] = i2;
+    steps[i2 * width] = STEP.missing;
+    const referenceItem = reference[i2 - 1];
+    for (let j2 = 1; j2 <= columns; j2 += 1) {
+      const paired = previous[j2 - 1] + (referenceItem === attempt[j2 - 1] ? 0 : 1);
+      const missing = previous[j2] + 1;
+      const extra = current[j2 - 1] + 1;
+      const cost = Math.min(paired, missing, extra);
+      current[j2] = cost;
+      steps[i2 * width + j2] = paired === cost ? STEP.pair : missing === cost ? STEP.missing : STEP.extra;
+    }
+    [previous, current] = [current, previous];
+  }
+  const path = [];
+  let i = rows;
+  let j = columns;
+  while (i > 0 || j > 0) {
+    const step = steps[i * width + j];
+    if (step === STEP.pair) {
+      i -= 1;
+      j -= 1;
+    } else if (step === STEP.missing) {
+      i -= 1;
+    } else {
+      j -= 1;
+    }
+    path.push({ step, referenceIndex: i, attemptIndex: j });
+  }
+  return path.reverse();
+}
+function alignWords(reference, attempt) {
+  const words = [];
+  let ordinal = 0;
+  for (const { step, referenceIndex, attemptIndex } of alignSequences(reference, attempt)) {
+    if (step === STEP.extra) {
+      words.push({
+        reference: "",
+        attempt: attempt[attemptIndex],
+        similarity: 0,
+        status: "extra"
+      });
+      continue;
+    }
+    ordinal += 1;
+    const referenceWord = reference[referenceIndex];
+    if (step === STEP.missing) {
+      words.push({
+        itemId: `w${ordinal}`,
+        reference: referenceWord,
+        attempt: "",
+        similarity: 0,
+        status: "missing"
+      });
+      continue;
+    }
+    const attemptWord = attempt[attemptIndex];
+    words.push({
+      itemId: `w${ordinal}`,
+      reference: referenceWord,
+      attempt: attemptWord,
+      similarity: similarity(referenceWord, attemptWord),
+      status: referenceWord === attemptWord ? "correct" : "incorrect"
+    });
+  }
+  return words;
+}
+
+// src/errors.ts
+var ActivitySchemaError = class extends Error {
+  constructor(activityType, errors) {
+    super(`Invalid activity data for type "${activityType}"`);
+    this.activityType = activityType;
+    this.errors = errors;
+    this.name = "ActivitySchemaError";
+  }
+  activityType;
+  errors;
+};
+var UnknownActivityTypeError = class extends Error {
+  constructor(activityType) {
+    super(`Activity type "${activityType}" is not registered`);
+    this.activityType = activityType;
+    this.name = "UnknownActivityTypeError";
+  }
+  activityType;
+};
+var RedactedScoringError = class extends Error {
+  constructor(activityType) {
+    super(
+      `Activity data for "${activityType}" carries no answer key (it looks redacted), so it cannot be scored. Score against the full activity data server-side. evaluate() answers this input without throwing, but it never grades it.`
+    );
+    this.activityType = activityType;
+    this.name = "RedactedScoringError";
+  }
+  activityType;
+};
+var DeferredScoringError = class extends Error {
+  constructor(activityType) {
+    super(
+      `Activity type "${activityType}" is graded asynchronously and has no synchronous score. Use evaluate() \u2014 it returns { status: 'deferred' } for this type.`
+    );
+    this.activityType = activityType;
+    this.name = "DeferredScoringError";
+  }
+  activityType;
+};
 
 // src/schemas/dictation.ts
-import { z as z3 } from "zod/v4";
-var DictationSlowMediaSchema = z3.looseObject({
-  type: z3.literal("audio"),
+import { z as z5 } from "zod/v4";
+var DictationSlowMediaSchema = z5.looseObject({
+  type: z5.literal("audio"),
   url: MediaUrlSchema,
-  alt: z3.string().min(1).optional()
+  alt: z5.string().min(1).optional()
 });
-var RuleTextSchema = z3.string().min(1).meta({ maxLength: DICTATION_MAX_EQUIVALENCE_LENGTH });
-var TranscriptTextSchema = z3.string().min(1).meta({ maxLength: DICTATION_MAX_TRANSCRIPT_LENGTH });
-var DictationEquivalenceSchema = z3.looseObject({
+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, {
@@ -1063,8 +1325,8 @@ var DictationEquivalenceSchema = z3.looseObject({
   error: `A rewrite is at most ${DICTATION_MAX_EQUIVALENCE_LENGTH} characters.`,
   path: ["to"]
 });
-var DictationToleranceSchema = z3.looseObject({
-  equivalences: z3.array(DictationEquivalenceSchema).max(DICTATION_MAX_EQUIVALENCES, {
+var DictationToleranceSchema = z5.looseObject({
+  equivalences: z5.array(DictationEquivalenceSchema).max(DICTATION_MAX_EQUIVALENCES, {
     error: `A dictation carries at most ${DICTATION_MAX_EQUIVALENCES} equivalence rules.`
   }).optional()
 });
@@ -1087,26 +1349,27 @@ function isEmpty(measured) {
   return measured.normalized === "";
 }
 function checkEvenAfterIssues(check) {
-  const guard = new z3.core.$ZodCheck({ check: "custom", when: () => true });
+  const guard = new z5.core.$ZodCheck({ check: "custom", when: () => true });
   guard._zod.check = check;
   return guard;
 }
-var DictationDataShape = z3.looseObject({
-  schemaVersion: z3.literal("1.0"),
-  type: z3.literal("dictation"),
-  id: z3.string().min(1),
-  title: z3.string().min(1),
+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: z3.array(TranscriptTextSchema).max(DICTATION_MAX_ACCEPTED_TRANSCRIPTS).optional(),
+  acceptedTranscripts: z5.array(TranscriptTextSchema).max(DICTATION_MAX_ACCEPTED_TRANSCRIPTS).optional(),
   media: MediaSchema.optional(),
   slowMedia: DictationSlowMediaSchema.optional(),
-  hints: z3.looseObject({ mode: z3.literal("progressive-words") }).optional(),
+  hints: z5.looseObject({ mode: z5.literal("progressive-words") }).optional(),
   tolerance: DictationToleranceSchema.optional(),
   feedback: FeedbackSchema.optional(),
-  passThreshold: z3.number().min(0).max(1).optional(),
-  locale: z3.string().optional(),
-  learningObjectives: z3.array(z3.string()).optional(),
-  difficultyLevel: z3.literal([1, 2, 3, 4, 5]).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) => {
@@ -1208,10 +1471,10 @@ var DictationDataSchema = DictationDataShape.check(
     }
     for (const field of ["media", "slowMedia"]) {
       const recording = data[field];
-      if (recording?.captionsUrl !== void 0) {
+      for (const captions of captionFieldsOf(recording)) {
         report(
-          [field, "captionsUrl"],
-          recording.captionsUrl,
+          [field, captions],
+          recording?.[captions],
           "A dictation recording cannot carry captions: the captions are the answer. Offer an accessible alternative as a different item."
         );
       }
@@ -1247,92 +1510,44 @@ var DictationDataSchema = DictationDataShape.check(
     }
   })
 );
-function groupCaptionsRevealDictation(group, hasCaptions = (captionsUrl) => captionsUrl !== void 0) {
-  const isObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
-  if (!isObject(group) || !isObject(group.stimulus) || !isObject(group.stimulus.media)) {
-    return false;
+var isObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+function captionFieldsOf(media, written = (captionsUrl) => captionsUrl !== void 0) {
+  if (!isObject(media)) {
+    return [];
   }
-  if (!hasCaptions(group.stimulus.media.captionsUrl) || !Array.isArray(group.items)) {
-    return false;
+  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;
   }
-  return group.items.some(
+  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/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()
-}).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/schemas/multiple-choice.ts
-import { z as z5 } from "zod/v4";
-var MultipleChoiceOptionMediaSchema = z5.looseObject({
+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: z5.enum(["image", "audio"]),
+  type: z6.enum(["image", "audio"]),
   url: MediaUrlSchema,
-  alt: z5.string().min(1).optional(),
+  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`.",
@@ -1341,30 +1556,31 @@ var MultipleChoiceOptionMediaSchema = z5.looseObject({
   error: "An option carries no playback policy. maxPlays, seek and rate are enforced only on the media above the question.",
   path: ["playback"]
 });
-var MultipleChoiceOptionSchema = z5.looseObject({
-  id: z5.string().min(1),
-  text: z5.string().min(1),
-  isCorrect: z5.boolean(),
-  feedback: z5.string().optional(),
+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 = z5.looseObject({
-  schemaVersion: z5.literal("1.0"),
-  type: z5.literal("multiple-choice"),
-  id: z5.string().min(1),
-  title: z5.string().min(1),
-  question: z5.string().min(1),
-  questionHtml: z5.string().optional(),
-  mode: z5.enum(["single", "multi"]),
-  options: z5.array(MultipleChoiceOptionSchema).min(2).max(26),
-  scoringStrategy: z5.enum(["all-or-nothing", "partial"]),
+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: z5.number().min(0).max(1).optional(),
-  shuffle: z5.boolean().optional(),
-  locale: z5.string().optional(),
-  learningObjectives: z5.array(z5.string()).optional(),
-  difficultyLevel: z5.literal([1, 2, 3, 4, 5]).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"]
@@ -1388,7 +1604,7 @@ 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";
+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})$/;
@@ -1396,49 +1612,50 @@ 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"),
+var ReadAloudSlowMediaSchema = z7.strictObject({
+  type: z7.literal("audio"),
   url: MediaUrlSchema,
-  alt: z6.string().min(1).optional()
+  alt: z7.string().min(1).optional()
 });
-var ReferenceTextSchema = z6.string().min(1).refine((text) => text.trim() !== "", {
+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 = 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 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 = z6.looseObject({
-  name: z6.enum(READ_ALOUD_DIMENSIONS),
-  weight: z6.number().min(0).max(READ_ALOUD_MAX_DIMENSION_WEIGHT)
+var ReadAloudDimensionWeightSchema = z7.looseObject({
+  name: z7.enum(READ_ALOUD_DIMENSIONS),
+  weight: z7.number().min(0).max(READ_ALOUD_MAX_DIMENSION_WEIGHT)
 });
-var ReadAloudScoringSchema = z6.looseObject({
-  dimensions: z6.array(ReadAloudDimensionWeightSchema).min(1).max(READ_ALOUD_MAX_DIMENSIONS)
+var ReadAloudScoringSchema = z7.looseObject({
+  dimensions: z7.array(ReadAloudDimensionWeightSchema).min(1).max(READ_ALOUD_MAX_DIMENSIONS)
 });
 function checkEvenAfterIssues2(check) {
-  const guard = new z6.core.$ZodCheck({ check: "custom", when: () => true });
+  const guard = new z7.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(),
+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: z6.string().regex(CANONICAL_LOCALE_RE, {
+  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: z6.number().min(0).max(1).optional(),
+  passThreshold: z7.number().min(0).max(1).optional(),
   feedback: FeedbackSchema.optional(),
-  learningObjectives: z6.array(z6.string()).optional(),
-  difficultyLevel: z6.literal([1, 2, 3, 4, 5]).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) => {
@@ -1554,21 +1771,21 @@ function countWords(text) {
 }
 
 // src/schemas/gap-select.ts
-import { z as z7 } from "zod/v4";
-var GapSelectChoiceSchema = z7.looseObject({
-  id: z7.string().min(1),
-  text: z7.string().min(1)
+import { z as z8 } from "zod/v4";
+var GapSelectChoiceSchema = z8.looseObject({
+  id: z8.string().min(1),
+  text: z8.string().min(1)
 });
-var GapSelectBankSchema = z7.looseObject({
-  id: z7.string().min(1),
-  choices: z7.array(GapSelectChoiceSchema).min(2)
+var GapSelectBankSchema = z8.looseObject({
+  id: z8.string().min(1),
+  choices: z8.array(GapSelectChoiceSchema).min(2)
 });
-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()
+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) {
@@ -1587,24 +1804,25 @@ function placeholderCounts(passage) {
   }
   return counts;
 }
-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(),
+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: 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(),
+  ai: AiPermissionsSchema.optional()
 }).refine(
   (data) => {
     const ids = (data.banks ?? []).map((bank) => bank.id);
@@ -1658,145 +1876,147 @@ var GapSelectDataSchema = z7.looseObject({
 );
 
 // src/schemas/written-response.ts
-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)
+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 = z8.looseObject({
-  label: z8.string().optional(),
-  criteria: z8.array(WrittenResponseRubricCriterionSchema).min(1)
+var WrittenResponseRubricSchema = z9.looseObject({
+  label: z9.string().optional(),
+  criteria: z9.array(WrittenResponseRubricCriterionSchema).min(1)
 });
-var RedactedWrittenResponseRubricCriterionSchema = z8.strictObject({
-  name: z8.string().min(1),
-  description: z8.string().optional(),
-  weight: z8.number().min(0)
+var RedactedWrittenResponseRubricCriterionSchema = z9.strictObject({
+  name: z9.string().min(1),
+  description: z9.string().optional(),
+  weight: z9.number().min(0)
 });
-var RedactedWrittenResponseRubricSchema = z8.strictObject({
-  label: z8.string().optional(),
-  criteria: z8.array(RedactedWrittenResponseRubricCriterionSchema).min(1)
+var RedactedWrittenResponseRubricSchema = z9.strictObject({
+  label: z9.string().optional(),
+  criteria: z9.array(RedactedWrittenResponseRubricCriterionSchema).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),
+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: z8.string().optional(),
+  languageTarget: z9.string().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()
+  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 z9 } from "zod/v4";
+import { z as z10 } from "zod/v4";
 var redactedBase = {
   /** Marker distinguishing a redacted projection from full activity data. */
-  redacted: z9.literal(true),
-  /** Slot identity, carried through redaction so the client and the plan agree. */
-  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: 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()
+  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 = 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 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 = z9.strictObject({
-  id: z9.string().min(1),
-  text: z9.string().min(1),
+var RedactedMultipleChoiceOptionSchema = z10.strictObject({
+  id: z10.string().min(1),
+  text: z10.string().min(1),
   media: RedactedMultipleChoiceOptionMediaSchema.optional()
 });
-var RedactedMultipleChoiceDataSchema = z9.strictObject({
+var RedactedMultipleChoiceDataSchema = z10.strictObject({
   ...redactedBase,
-  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()
+  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 = z9.strictObject({
-  id: z9.string().min(1),
-  hint: z9.string().optional()
+var RedactedBlankConfigSchema = z10.strictObject({
+  id: z10.string().min(1),
+  hint: z10.string().optional()
 });
-var RedactedFillInTheBlanksDataSchema = z9.strictObject({
+var RedactedFillInTheBlanksDataSchema = z10.strictObject({
   ...redactedBase,
-  type: z9.literal("fill-in-the-blanks"),
-  passage: z9.string().min(1),
-  passageHtml: z9.string().optional(),
-  blanks: z9.array(RedactedBlankConfigSchema).min(1)
+  type: z10.literal("fill-in-the-blanks"),
+  passage: z10.string().min(1),
+  passageHtml: z10.string().optional(),
+  blanks: z10.array(RedactedBlankConfigSchema).min(1)
 });
-var RedactedGapSelectChoiceSchema = z9.strictObject({
-  id: z9.string().min(1),
-  text: z9.string().min(1)
+var RedactedGapSelectChoiceSchema = z10.strictObject({
+  id: z10.string().min(1),
+  text: z10.string().min(1)
 });
-var RedactedGapSelectBankSchema = z9.strictObject({
-  id: z9.string().min(1),
-  choices: z9.array(RedactedGapSelectChoiceSchema).min(2)
+var RedactedGapSelectBankSchema = z10.strictObject({
+  id: z10.string().min(1),
+  choices: z10.array(RedactedGapSelectChoiceSchema).min(2)
 });
-var RedactedGapSelectGapSchema = z9.strictObject({
-  id: z9.string().min(1),
-  choices: z9.array(RedactedGapSelectChoiceSchema).min(2).optional(),
-  bankId: z9.string().min(1).optional()
+var RedactedGapSelectGapSchema = z10.strictObject({
+  id: z10.string().min(1),
+  choices: z10.array(RedactedGapSelectChoiceSchema).min(2).optional(),
+  bankId: z10.string().min(1).optional()
 });
-var RedactedGapSelectDataSchema = z9.strictObject({
+var RedactedGapSelectDataSchema = z10.strictObject({
   ...redactedBase,
-  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()
+  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 = z9.strictObject({
+var RedactedWrittenResponseDataSchema = z10.strictObject({
   ...redactedBase,
-  type: z9.literal("written-response"),
-  prompt: z9.string(),
-  promptHtml: z9.string().optional(),
-  minWords: z9.number().int().min(0),
-  maxWords: z9.number().int().min(1),
+  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: z9.string().optional()
+  languageTarget: z10.string().optional()
 });
-var RedactedDictationSlowMediaSchema = z9.strictObject({
-  type: z9.literal("audio"),
+var RedactedDictationSlowMediaSchema = z10.strictObject({
+  type: z10.literal("audio"),
   url: MediaUrlSchema,
-  alt: z9.string().min(1).optional()
+  alt: z10.string().min(1).optional()
 });
-var RedactedDictationDataSchema = z9.strictObject({
+var RedactedDictationDataSchema = z10.strictObject({
   ...redactedBase,
-  type: z9.literal("dictation"),
+  type: z10.literal("dictation"),
   slowMedia: RedactedDictationSlowMediaSchema.optional(),
-  hints: z9.strictObject({ mode: z9.literal("progressive-words") }).optional()
+  hints: z10.strictObject({ mode: z10.literal("progressive-words") }).optional()
 }).check((ctx) => {
   const data = ctx.value;
-  if (data.media?.captionsUrl !== void 0) {
+  for (const captions of captionFieldsOf(data.media)) {
     ctx.issues.push({
       code: "custom",
-      input: data.media.captionsUrl,
+      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", "captionsUrl"]
+      path: ["media", captions]
     });
   }
   if (data.slowMedia !== void 0 && data.media?.playback?.maxPlays !== void 0) {
@@ -1816,23 +2036,23 @@ var RedactedDictationDataSchema = z9.strictObject({
     });
   }
 });
-var RedactedReadAloudDataSchema = z9.strictObject({
+var RedactedReadAloudDataSchema = z10.strictObject({
   ...redactedBase,
-  type: z9.literal("read-aloud"),
-  locale: z9.string().regex(CANONICAL_LOCALE_RE),
-  instructions: z9.string().optional(),
-  referenceText: z9.string().min(1),
+  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: 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()
+  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: z9.strictObject({
-    dimensions: z9.array(
-      z9.strictObject({
-        name: z9.enum(READ_ALOUD_DIMENSIONS),
-        weight: z9.number().min(0).max(READ_ALOUD_MAX_DIMENSION_WEIGHT)
+  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)
   })
@@ -1872,197 +2092,6 @@ var RedactedReadAloudDataSchema = z9.strictObject({
   }
 });
 
-// src/scoring/dictation/edit-distance.ts
-function codePoints(text) {
-  return Array.from(text, (character) => character.codePointAt(0));
-}
-function editDistance(a, b) {
-  if (a === b) {
-    return 0;
-  }
-  let left = codePoints(a);
-  let right = codePoints(b);
-  if (left.length < right.length) {
-    [left, right] = [right, left];
-  }
-  if (right.length === 0) {
-    return left.length;
-  }
-  let previous = new Uint32Array(right.length + 1);
-  let current = new Uint32Array(right.length + 1);
-  for (let j = 0; j <= right.length; j += 1) {
-    previous[j] = j;
-  }
-  for (let i = 1; i <= left.length; i += 1) {
-    current[0] = i;
-    const leftPoint = left[i - 1];
-    for (let j = 1; j <= right.length; j += 1) {
-      const deletion = previous[j] + 1;
-      const insertion = current[j - 1] + 1;
-      const substitution = previous[j - 1] + (leftPoint === right[j - 1] ? 0 : 1);
-      current[j] = Math.min(deletion, insertion, substitution);
-    }
-    [previous, current] = [current, previous];
-  }
-  return previous[right.length];
-}
-function similarity(a, b) {
-  const max = Math.max(codePoints(a).length, codePoints(b).length);
-  return max === 0 ? 0 : (max - editDistance(a, b)) / max;
-}
-
-// src/scoring/dictation/align.ts
-function dictationReferenceWords(data) {
-  return rawCandidates(data).map(
-    (candidate) => tokensOf(normalizeCandidate(candidate, data)).map((word, index) => ({
-      itemId: `w${index + 1}`,
-      word
-    }))
-  );
-}
-function alignDictation(data, text) {
-  const raw = typeof text === "string" ? text : "";
-  const capped = truncateCodePoints(raw, DICTATION_MAX_TEXT_LENGTH);
-  const { text: normalized, cut } = normalizeDictationTextBounded(capped, data.tolerance);
-  const attempt = cutAt(normalized, DICTATION_MAX_TEXT_LENGTH);
-  const truncated = cut || capped.length < raw.length || attempt.length < normalized.length;
-  const candidates = [];
-  rawCandidates(data).forEach((candidate, index) => {
-    const candidateText = normalizeCandidate(candidate, data);
-    if (candidateText !== "") {
-      candidates.push({ index, text: candidateText });
-    }
-  });
-  if (candidates.length === 0) {
-    return { candidateIndex: -1, reference: "", attempt, truncated, similarity: 0, words: [] };
-  }
-  let chosen = candidates[0];
-  let best = similarity(chosen.text, attempt);
-  for (const candidate of candidates.slice(1)) {
-    const candidateSimilarity = similarity(candidate.text, attempt);
-    if (candidateSimilarity > best) {
-      best = candidateSimilarity;
-      chosen = candidate;
-    }
-  }
-  return {
-    candidateIndex: chosen.index,
-    reference: chosen.text,
-    attempt,
-    truncated,
-    similarity: best,
-    words: alignWords(tokensOf(chosen.text), tokensOf(attempt))
-  };
-}
-function rawCandidates(data) {
-  return [
-    data.transcript,
-    ...Array.isArray(data.acceptedTranscripts) ? data.acceptedTranscripts.slice(0, DICTATION_MAX_ACCEPTED_TRANSCRIPTS) : []
-  ];
-}
-function normalizeCandidate(candidate, data) {
-  return typeof candidate === "string" ? cutAt(
-    normalizeDictationText(
-      truncateCodePoints(candidate, DICTATION_MAX_TRANSCRIPT_LENGTH),
-      data.tolerance
-    ),
-    DICTATION_MAX_TRANSCRIPT_LENGTH
-  ) : "";
-}
-function cutAt(normalized, max) {
-  const cut = truncateCodePoints(normalized, max);
-  return cut.endsWith(" ") ? cut.slice(0, -1) : cut;
-}
-function tokensOf(normalized) {
-  return normalized === "" ? [] : normalized.split(" ");
-}
-var STEP = {
-  /** A reference element paired with an attempt element — equal or substituted. */
-  pair: 0,
-  /** A reference element the attempt lacks. */
-  missing: 1,
-  /** An attempt element the reference lacks. */
-  extra: 2
-};
-function alignSequences(reference, attempt) {
-  const rows = reference.length;
-  const columns = attempt.length;
-  const width = columns + 1;
-  const steps = new Uint8Array((rows + 1) * width);
-  let previous = new Uint32Array(width);
-  let current = new Uint32Array(width);
-  for (let j2 = 0; j2 <= columns; j2 += 1) {
-    previous[j2] = j2;
-    steps[j2] = STEP.extra;
-  }
-  for (let i2 = 1; i2 <= rows; i2 += 1) {
-    current[0] = i2;
-    steps[i2 * width] = STEP.missing;
-    const referenceItem = reference[i2 - 1];
-    for (let j2 = 1; j2 <= columns; j2 += 1) {
-      const paired = previous[j2 - 1] + (referenceItem === attempt[j2 - 1] ? 0 : 1);
-      const missing = previous[j2] + 1;
-      const extra = current[j2 - 1] + 1;
-      const cost = Math.min(paired, missing, extra);
-      current[j2] = cost;
-      steps[i2 * width + j2] = paired === cost ? STEP.pair : missing === cost ? STEP.missing : STEP.extra;
-    }
-    [previous, current] = [current, previous];
-  }
-  const path = [];
-  let i = rows;
-  let j = columns;
-  while (i > 0 || j > 0) {
-    const step = steps[i * width + j];
-    if (step === STEP.pair) {
-      i -= 1;
-      j -= 1;
-    } else if (step === STEP.missing) {
-      i -= 1;
-    } else {
-      j -= 1;
-    }
-    path.push({ step, referenceIndex: i, attemptIndex: j });
-  }
-  return path.reverse();
-}
-function alignWords(reference, attempt) {
-  const words = [];
-  let ordinal = 0;
-  for (const { step, referenceIndex, attemptIndex } of alignSequences(reference, attempt)) {
-    if (step === STEP.extra) {
-      words.push({
-        reference: "",
-        attempt: attempt[attemptIndex],
-        similarity: 0,
-        status: "extra"
-      });
-      continue;
-    }
-    ordinal += 1;
-    const referenceWord = reference[referenceIndex];
-    if (step === STEP.missing) {
-      words.push({
-        itemId: `w${ordinal}`,
-        reference: referenceWord,
-        attempt: "",
-        similarity: 0,
-        status: "missing"
-      });
-      continue;
-    }
-    const attemptWord = attempt[attemptIndex];
-    words.push({
-      itemId: `w${ordinal}`,
-      reference: referenceWord,
-      attempt: attemptWord,
-      similarity: similarity(referenceWord, attemptWord),
-      status: referenceWord === attemptWord ? "correct" : "incorrect"
-    });
-  }
-  return words;
-}
-
 // src/scoring/text-match.ts
 var COMBINING_MARKS_RE = /\p{M}/gu;
 var PUNCTUATION_RE2 = /\p{P}/gu;
@@ -2187,6 +2216,7 @@ var DRAFT_ISSUE_SEVERITY = {
   scoring_strategy_required: "incomplete",
   pass_threshold_invalid: "invalid",
   difficulty_level_invalid: "invalid",
+  ai_permissions_invalid: "invalid",
   feedback_empty: "incomplete",
   redacted_data: "invalid",
   media_type_required: "incomplete",
@@ -2421,6 +2451,30 @@ function checkSharedOptional(draft) {
       )
     );
   }
+  const ai = draft.ai;
+  if (!isUnset(ai)) {
+    if (!isRecord(ai)) {
+      issues.push(
+        issue(
+          "ai_permissions_invalid",
+          ["ai"],
+          "AI permissions must be an object of on/off flags, such as { hints: false }."
+        )
+      );
+    } else {
+      for (const key of ["explanations", "hints"]) {
+        if (!isUnset(ai[key]) && typeof ai[key] !== "boolean") {
+          issues.push(
+            issue(
+              "ai_permissions_invalid",
+              ["ai", key],
+              "Set this to true or false, or remove it."
+            )
+          );
+        }
+      }
+    }
+  }
   const feedback = draft.feedback;
   if (isRecord(feedback)) {
     for (const key of ["correct", "incorrect"]) {
@@ -2656,10 +2710,8 @@ function checkRecording(media) {
       )
     );
   }
-  if (!isUnset(media.captionsUrl)) {
-    issues.push(
-      issue("dc_captions_not_allowed", ["media", "captionsUrl"], CAPTIONS_ARE_THE_ANSWER)
-    );
+  for (const captions of captionFieldsOf(media, (captionsUrl) => !isUnset(captionsUrl))) {
+    issues.push(issue("dc_captions_not_allowed", ["media", captions], CAPTIONS_ARE_THE_ANSWER));
   }
   return issues;
 }
@@ -2684,10 +2736,8 @@ function checkSlowRecording(draft) {
       DictationSlowMediaSchema
     )
   );
-  if (!isUnset(slow.captionsUrl)) {
-    issues.push(
-      issue("dc_captions_not_allowed", ["slowMedia", "captionsUrl"], CAPTIONS_ARE_THE_ANSWER)
-    );
+  for (const captions of captionFieldsOf(slow, (captionsUrl) => !isUnset(captionsUrl))) {
+    issues.push(issue("dc_captions_not_allowed", ["slowMedia", captions], CAPTIONS_ARE_THE_ANSWER));
   }
   if (slow.playback !== void 0) {
     issues.push(
@@ -4064,7 +4114,11 @@ var SHARED_PUBLIC_FIELDS = {
   passThreshold: "public",
   locale: "public",
   learningObjectives: "public",
-  difficultyLevel: "public"
+  difficultyLevel: "public",
+  // What an author allows AI to do for the item. Public, field by field: a
+  // review that explains an answer must still honour an author who said no,
+  // and an unclassified key parked inside it must not ride along.
+  ai: { explanations: "public", hints: "public" }
 };
 var FEEDBACK_FIELD_POLICY = {
   correct: "answer-key",
@@ -4337,10 +4391,18 @@ registerActivityType(dictationType);
 registerActivityType(readAloudType);
 
 export {
-  ActivitySchemaError,
-  UnknownActivityTypeError,
-  RedactedScoringError,
-  DeferredScoringError,
+  AiPermissionsSchema,
+  FeedbackSchema,
+  MediaUrlSchema,
+  NativeControlHintSchema,
+  MediaPlaybackSchema,
+  MediaTrackSchema,
+  MediaSchema,
+  RedactedMediaSchema,
+  PLACEHOLDER_RE,
+  TextMatchPolicySchema,
+  BlankConfigSchema,
+  FillInTheBlanksDataSchema,
   withValidationScope,
   DICTATION_MAX_TRANSCRIPT_LENGTH,
   DICTATION_MAX_TEXT_LENGTH,
@@ -4349,18 +4411,19 @@ export {
   DICTATION_MAX_ACCEPTED_TRANSCRIPTS,
   codePointLength,
   normalizeDictationText,
-  FeedbackSchema,
-  MediaUrlSchema,
-  NativeControlHintSchema,
-  MediaPlaybackSchema,
-  MediaTrackSchema,
-  MediaSchema,
-  RedactedMediaSchema,
+  dictationReferenceWords,
+  alignDictation,
+  STEP,
+  alignSequences,
+  ActivitySchemaError,
+  UnknownActivityTypeError,
+  RedactedScoringError,
+  DeferredScoringError,
   DictationSlowMediaSchema,
   DictationEquivalenceSchema,
   DictationToleranceSchema,
   DictationDataSchema,
-  groupCaptionsRevealDictation,
+  groupCaptionsField,
   GROUP_CAPTIONS_REVEAL_DICTATION,
   DRAFT_ISSUE_SEVERITY,
   issue,
@@ -4373,9 +4436,6 @@ export {
   covers,
   pathKey,
   coveredPathsOf,
-  TextMatchPolicySchema,
-  BlankConfigSchema,
-  FillInTheBlanksDataSchema,
   MultipleChoiceOptionMediaSchema,
   MultipleChoiceOptionSchema,
   MultipleChoiceDataSchema,
@@ -4409,10 +4469,6 @@ export {
   RedactedDictationSlowMediaSchema,
   RedactedDictationDataSchema,
   RedactedReadAloudDataSchema,
-  dictationReferenceWords,
-  alignDictation,
-  STEP,
-  alignSequences,
   levenshteinDistance,
   matchText,
   defineActivityType,
@@ -4427,4 +4483,4 @@ export {
   dictationType,
   readAloudType
 };
-//# sourceMappingURL=chunk-DPHX4E7X.js.map
+//# sourceMappingURL=chunk-D3GP5MET.js.map