@intellectif/lk-core 1.1.0 → 1.2.0

package/dist/chunk-MXI26H62.cjs

@@ -0,0 +1,2207 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+
+
+
+
+var _chunk4YANYTFNcjs = require('./chunk-4YANYTFN.cjs');
+
+
+
+
+
+var _chunkZWXQSKCXcjs = require('./chunk-ZWXQSKCX.cjs');
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+var _chunk7THXD7ANcjs = require('./chunk-7THXD7AN.cjs');
+
+// src/ai-text.ts
+function cleanText(text2) {
+  return text2.replace(/\r\n?/g, "\n").replace(/[\u0000-\u0008\u000B\u000C\u000E-\u001F\u007F-\u009F\u2028\u2029]/g, "").replace(/\n{3,}/g, "\n\n").trim();
+}
+function provenanceOf(raw) {
+  if (typeof raw !== "object" || raw === null) {
+    return void 0;
+  }
+  const kept = {};
+  for (const key of ["model", "promptHash", "generatedAt"]) {
+    const value = raw[key];
+    if (typeof value === "string" && value.length > 0 && value.length <= 200) {
+      kept[key] = value;
+    }
+  }
+  return Object.keys(kept).length > 0 ? kept : void 0;
+}
+function usageOf(raw) {
+  if (typeof raw !== "object" || raw === null) {
+    return void 0;
+  }
+  const kept = {};
+  for (const key of ["promptTokens", "completionTokens", "costUsd"]) {
+    const value = raw[key];
+    if (typeof value === "number" && Number.isFinite(value) && value >= 0) {
+      kept[key] = value;
+    }
+  }
+  return Object.keys(kept).length > 0 ? kept : void 0;
+}
+var QUOTE_FOLD = {
+  "\u2018": "'",
+  "\u2019": "'",
+  "\u201B": "'",
+  "\u2032": "'",
+  "\u201C": '"',
+  "\u201D": '"',
+  "\u201E": '"',
+  "\u2033": '"'
+};
+function folded(text2) {
+  let chars = "";
+  const from = [];
+  let space = false;
+  for (let at = 0; at < text2.length; at += 1) {
+    const char = text2[at];
+    if (/\s/u.test(char)) {
+      if (!space) {
+        chars += " ";
+        from.push(at);
+        space = true;
+      }
+      continue;
+    }
+    space = false;
+    chars += _nullishCoalesce(QUOTE_FOLD[char], () => ( char));
+    from.push(at);
+  }
+  return { chars, from };
+}
+var needle = (quote) => folded(quote).chars.trim();
+
+// src/ai.ts
+var AI_EXPLANATION_TYPES = [
+  "multiple-choice",
+  "fill-in-the-blanks",
+  "gap-select",
+  "dictation"
+];
+var AI_HINT_TYPES = [
+  "multiple-choice",
+  "fill-in-the-blanks",
+  "gap-select"
+];
+var AI_TEXT_MAX_LENGTH = 2e3;
+function aiSupports(activityType, feature) {
+  if (feature === "writing-feedback") {
+    return activityType === "written-response";
+  }
+  if (feature === "pronunciation-coaching") {
+    return activityType === "read-aloud";
+  }
+  const types = feature === "hint" ? AI_HINT_TYPES : AI_EXPLANATION_TYPES;
+  return types.includes(activityType);
+}
+function aiAllowedByContent(data, feature) {
+  const permissions = data.ai;
+  if (typeof permissions !== "object" || permissions === null) {
+    return true;
+  }
+  const key = feature === "hint" ? "hints" : "explanations";
+  return permissions[key] !== false;
+}
+function aiGradeOf(result) {
+  const ratio = result.maxScore > 0 ? result.score / result.maxScore : 0;
+  let category = "partly-correct";
+  if (ratio >= 1 - 1e-9) {
+    category = "correct";
+  } else if (ratio <= 1e-9) {
+    category = "incorrect";
+  }
+  return { score: result.score, maxScore: result.maxScore, passed: result.passed, category };
+}
+var legacyCorrect = (detail) => detail.correct === true;
+function detailRight(detail) {
+  const outcome = detail.outcome;
+  return outcome === void 0 ? legacyCorrect(detail) : outcome === "correct";
+}
+function isAnswerOption(detail, chosen) {
+  switch (detail.outcome) {
+    case "correct":
+    case "incorrect-omission":
+      return true;
+    case "incorrect":
+    case "correct-omission":
+      return false;
+    default:
+      return chosen ? legacyCorrect(detail) : !legacyCorrect(detail);
+  }
+}
+var firstString = (value) => Array.isArray(value) ? value[0] : value;
+var listOf = (value) => value === void 0 ? null : Array.isArray(value) ? [...value] : [value];
+function emptyResponse(type) {
+  switch (type) {
+    case "multiple-choice":
+      return { type: "multiple-choice", selectedOptionIds: [] };
+    case "fill-in-the-blanks":
+      return { type: "fill-in-the-blanks", answers: {} };
+    case "gap-select":
+      return { type: "gap-select", selections: {} };
+    case "dictation":
+      return { type: "dictation", text: "" };
+    default:
+      return null;
+  }
+}
+var base = (data) => ({
+  activityId: data.id,
+  title: data.title,
+  ...typeof data.locale === "string" ? { locale: data.locale } : {}
+});
+function buildAiFacts(data, response, details) {
+  const byId = new Map((_nullishCoalesce(details, () => ( []))).map((detail) => [detail.itemId, detail]));
+  const full = data.redacted !== true;
+  switch (data.type) {
+    case "multiple-choice": {
+      const item = data;
+      const chosen = new Set(
+        _optionalChain([response, 'optionalAccess', _ => _.type]) === "multiple-choice" ? response.selectedOptionIds : []
+      );
+      return {
+        ...base(data),
+        activityType: "multiple-choice",
+        question: item.question,
+        mode: item.mode,
+        options: item.options.map((option) => {
+          const detail = byId.get(option.id);
+          const wasChosen = chosen.has(option.id);
+          let correct = null;
+          if (full && typeof option.isCorrect === "boolean") {
+            correct = option.isCorrect;
+          } else if (detail !== void 0) {
+            correct = isAnswerOption(detail, wasChosen);
+          }
+          return {
+            id: option.id,
+            text: option.text,
+            chosen: wasChosen,
+            correct,
+            ...typeof option.feedback === "string" ? { feedback: option.feedback } : {}
+          };
+        })
+      };
+    }
+    case "fill-in-the-blanks": {
+      const item = data;
+      const answers = _optionalChain([response, 'optionalAccess', _2 => _2.type]) === "fill-in-the-blanks" ? response.answers : {};
+      const blanks = new Map(item.blanks.map((blank) => [blank.id, blank]));
+      return {
+        ...base(data),
+        activityType: "fill-in-the-blanks",
+        passage: _chunk7THXD7ANcjs.numberedPassage.call(void 0, item.passage),
+        blanks: _chunk7THXD7ANcjs.placeholderOrder.call(void 0, item.passage).map((id, index) => {
+          const blank = blanks.get(id);
+          const detail = byId.get(id);
+          const accepted = full && Array.isArray(_optionalChain([blank, 'optionalAccess', _3 => _3.acceptedAnswers])) ? [...blank.acceptedAnswers] : listOf(_optionalChain([detail, 'optionalAccess', _4 => _4.correctResponse]));
+          return {
+            id,
+            position: index + 1,
+            typed: typeof answers[id] === "string" ? answers[id] : "",
+            accepted,
+            correct: detail === void 0 ? null : detailRight(detail),
+            ...typeof _optionalChain([blank, 'optionalAccess', _5 => _5.hint]) === "string" ? { hint: blank.hint } : {},
+            ...typeof _optionalChain([blank, 'optionalAccess', _6 => _6.feedback]) === "string" ? { feedback: blank.feedback } : {}
+          };
+        })
+      };
+    }
+    case "gap-select": {
+      const item = data;
+      const selections = _optionalChain([response, 'optionalAccess', _7 => _7.type]) === "gap-select" ? response.selections : {};
+      const gaps = new Map(item.gaps.map((gap) => [gap.id, gap]));
+      const banks = new Map((_nullishCoalesce(item.banks, () => ( []))).map((bank) => [bank.id, bank]));
+      return {
+        ...base(data),
+        activityType: "gap-select",
+        passage: _chunk7THXD7ANcjs.numberedPassage.call(void 0, item.passage),
+        gaps: _chunk7THXD7ANcjs.placeholderOrder.call(void 0, item.passage).map((id, index) => {
+          const gap = gaps.get(id);
+          const choices = _nullishCoalesce(_optionalChain([gap, 'optionalAccess', _8 => _8.choices]), () => ( (_optionalChain([gap, 'optionalAccess', _9 => _9.bankId]) === void 0 ? [] : _nullishCoalesce(_optionalChain([banks, 'access', _10 => _10.get, 'call', _11 => _11(gap.bankId), 'optionalAccess', _12 => _12.choices]), () => ( [])))));
+          const textOf = (choiceId) => choiceId === void 0 ? null : _nullishCoalesce(_optionalChain([choices, 'access', _13 => _13.find, 'call', _14 => _14((choice) => choice.id === choiceId), 'optionalAccess', _15 => _15.text]), () => ( null));
+          const detail = byId.get(id);
+          const answerId = full && typeof _optionalChain([gap, 'optionalAccess', _16 => _16.correctChoiceId]) === "string" ? gap.correctChoiceId : firstString(_optionalChain([detail, 'optionalAccess', _17 => _17.correctResponse]));
+          return {
+            id,
+            position: index + 1,
+            choices: choices.map((choice) => choice.text),
+            chosen: textOf(selections[id]),
+            answer: textOf(answerId),
+            correct: detail === void 0 ? null : detailRight(detail),
+            ...typeof _optionalChain([gap, 'optionalAccess', _18 => _18.feedback]) === "string" ? { feedback: gap.feedback } : {}
+          };
+        })
+      };
+    }
+    case "dictation": {
+      const item = data;
+      const typed = _optionalChain([response, 'optionalAccess', _19 => _19.type]) === "dictation" ? response.text : "";
+      const hasKey = full && typeof item.transcript === "string";
+      let words = null;
+      if (hasKey) {
+        words = _chunk7THXD7ANcjs.alignDictation.call(void 0, item, typed).words.map((word) => ({
+          expected: word.reference,
+          typed: word.attempt,
+          status: word.status
+        }));
+      } else if (details !== null && details.length > 0) {
+        words = details.map((detail) => {
+          const expected = _nullishCoalesce(firstString(detail.correctResponse), () => ( ""));
+          const attempt = _nullishCoalesce(firstString(detail.learnerResponse), () => ( ""));
+          let status = "incorrect";
+          if (detailRight(detail)) {
+            status = "correct";
+          } else if (attempt === "") {
+            status = "missing";
+          } else if (expected === "") {
+            status = "extra";
+          }
+          return { expected, typed: attempt, status };
+        });
+      }
+      return {
+        ...base(data),
+        activityType: "dictation",
+        transcript: hasKey ? item.transcript : null,
+        typed,
+        words
+      };
+    }
+    default:
+      return null;
+  }
+}
+function gradeLocally(data, response) {
+  if (data.redacted === true) {
+    return null;
+  }
+  try {
+    const result = _chunk4YANYTFNcjs.score.call(void 0, data.type, data, response);
+    return { details: result.details, grade: aiGradeOf(result) };
+  } catch (e) {
+    return null;
+  }
+}
+function aiExplanationRequest(input) {
+  const { data, response, outcome, learnerLocale } = input;
+  if (!aiSupports(data.type, "explanation") || !aiAllowedByContent(data, "explanation")) {
+    return null;
+  }
+  let details = null;
+  let grade = null;
+  if (_optionalChain([outcome, 'optionalAccess', _20 => _20.status]) === "scored") {
+    const { score: recorded, maxScore, passed } = outcome;
+    if (!_chunk4YANYTFNcjs.isGradeInRange.call(void 0, recorded, maxScore)) {
+      return null;
+    }
+    details = outcome.details;
+    grade = aiGradeOf({ score: recorded, maxScore, passed });
+  } else if (response !== null) {
+    const local = gradeLocally(data, response);
+    if (local !== null) {
+      details = local.details;
+      grade = local.grade;
+    }
+  }
+  if (grade === null) {
+    return null;
+  }
+  const facts = buildAiFacts(data, response, details);
+  if (facts === null) {
+    return null;
+  }
+  return {
+    feature: "explanation",
+    facts,
+    grade,
+    ...learnerLocale !== void 0 ? { learnerLocale } : {}
+  };
+}
+function aiHintRequest(input) {
+  const { data, previousHints, learnerLocale } = input;
+  if (!aiSupports(data.type, "hint") || !aiAllowedByContent(data, "hint") || data.redacted === true) {
+    return null;
+  }
+  const response = _nullishCoalesce(input.response, () => ( emptyResponse(data.type)));
+  const local = response === null ? null : gradeLocally(data, response);
+  const facts = buildAiFacts(data, response, _nullishCoalesce(_optionalChain([local, 'optionalAccess', _21 => _21.details]), () => ( null)));
+  if (facts === null) {
+    return null;
+  }
+  return {
+    feature: "hint",
+    facts,
+    hintNumber: previousHints.length + 1,
+    previousHints: [...previousHints],
+    ...learnerLocale !== void 0 ? { learnerLocale } : {}
+  };
+}
+var VERDICTS = ["correct", "partly-correct", "incorrect"];
+function readAiTextResult(raw) {
+  if (typeof raw !== "object" || raw === null || Array.isArray(raw)) {
+    return { ok: false, refusal: "malformed" };
+  }
+  const record = raw;
+  if (typeof record.text !== "string") {
+    return { ok: false, refusal: "malformed" };
+  }
+  if (record.verdict !== void 0 && !VERDICTS.includes(record.verdict)) {
+    return { ok: false, refusal: "malformed" };
+  }
+  const text2 = cleanText(record.text);
+  if (text2 === "") {
+    return { ok: false, refusal: "empty" };
+  }
+  if ([...text2].length > AI_TEXT_MAX_LENGTH) {
+    return { ok: false, refusal: "too-long" };
+  }
+  const provenance = provenanceOf(record.provenance);
+  const usage = usageOf(record.usage);
+  return {
+    ok: true,
+    result: {
+      text: text2,
+      ...record.verdict !== void 0 ? { verdict: record.verdict } : {},
+      ...provenance !== void 0 ? { provenance } : {},
+      ...usage !== void 0 ? { usage } : {}
+    }
+  };
+}
+function checkAiExplanation(raw, request) {
+  const read = readAiTextResult(raw);
+  if (!read.ok) {
+    return read;
+  }
+  if (read.result.verdict !== void 0 && read.result.verdict !== request.grade.category) {
+    return { ok: false, refusal: "contradicts-grade" };
+  }
+  return read;
+}
+function checkAiHint(raw, request) {
+  const read = readAiTextResult(raw);
+  if (!read.ok) {
+    return read;
+  }
+  if (hintRevealsAnswer(request.facts, read.result.text)) {
+    return { ok: false, refusal: "reveals-answer" };
+  }
+  return read;
+}
+function hintRevealsAnswer(facts, hint) {
+  const reveals = (answer, passage, position) => _chunk7THXD7ANcjs.revealsAnswer.call(void 0, hint, answer, passage, position);
+  switch (facts.activityType) {
+    case "multiple-choice":
+      return facts.options.some((option) => option.correct === true && reveals(option.text));
+    case "fill-in-the-blanks":
+      return facts.blanks.some(
+        (blank) => (_nullishCoalesce(blank.accepted, () => ( []))).some((answer) => reveals(answer, facts.passage, blank.position))
+      );
+    case "gap-select":
+      return facts.gaps.some(
+        (gap) => gap.answer !== null && reveals(gap.answer, facts.passage, gap.position)
+      );
+    case "dictation":
+      return false;
+    default:
+      return false;
+  }
+}
+
+// src/ai-coaching.ts
+var AI_COACHING_MAX_WORDS = 20;
+var AI_COACHING_MAX_TIP_LENGTH = 500;
+var MAX_SYMBOL_LENGTH = 16;
+var DIMENSIONS = ["accuracy", "fluency", "completeness", "prosody"];
+var hundredths = (value) => Math.round(value * 1e4) / 100;
+var isFiniteNumber = (value) => typeof value === "number" && Number.isFinite(value);
+function soundsOf(word) {
+  const sounds = [];
+  for (const phoneme of _nullishCoalesce(_optionalChain([word, 'optionalAccess', _22 => _22.phonemes]), () => ( []))) {
+    if (typeof phoneme.symbol !== "string") {
+      continue;
+    }
+    sounds.push({
+      symbol: phoneme.symbol,
+      ...phoneme.accuracy !== void 0 ? { accuracy: phoneme.accuracy } : {},
+      ...phoneme.heardAs !== void 0 && phoneme.heardAs.length > 0 ? { heardAs: phoneme.heardAs.map(({ symbol, score: score2 }) => ({ symbol, score: score2 })) } : {}
+    });
+  }
+  return sounds.length > 0 ? sounds : void 0;
+}
+function fromAssessment(item, assessment) {
+  const words = _chunk4YANYTFNcjs.alignReadAloud.call(void 0, item, assessment).map((entry) => {
+    const sounds = entry.itemId !== void 0 && entry.wordIndex !== void 0 ? soundsOf(assessment.words[entry.wordIndex]) : void 0;
+    return {
+      ...entry.itemId !== void 0 ? { itemId: entry.itemId } : {},
+      word: entry.reference,
+      heard: entry.heard,
+      state: entry.state,
+      ...entry.accuracy !== void 0 ? { accuracy: entry.accuracy } : {},
+      ...sounds !== void 0 ? { sounds } : {}
+    };
+  });
+  const scores = {};
+  for (const dimension of DIMENSIONS) {
+    const value = assessment.scores[dimension];
+    if (value !== void 0) {
+      scores[dimension] = value;
+    }
+  }
+  return {
+    assessor: assessment.assessor.kind,
+    ...assessment.phonemeAlphabet !== void 0 ? { phonemeAlphabet: assessment.phonemeAlphabet } : {},
+    scores,
+    words
+  };
+}
+var marksThisText = (item, assessment) => _chunk4YANYTFNcjs.validateSpeechAssessment.call(void 0, assessment).success && assessment.status === "assessed" && assessment.task === "scripted" && assessment.locale === item.locale && assessment.referenceText === item.referenceText;
+var STATE_OF_OUTCOME = {
+  correct: "correct",
+  incorrect: "mispronounced",
+  "incorrect-omission": "omitted"
+};
+function fromGrade(grade) {
+  if (!Array.isArray(grade.details) || grade.details.length === 0) {
+    return null;
+  }
+  const words = [];
+  for (const detail of grade.details) {
+    const state = STATE_OF_OUTCOME[detail.outcome];
+    if (state === void 0 || typeof detail.itemId !== "string") {
+      continue;
+    }
+    const text2 = (value) => Array.isArray(value) ? value.join(" ") : value;
+    words.push({
+      itemId: detail.itemId,
+      word: text2(detail.correctResponse),
+      heard: text2(detail.learnerResponse),
+      state,
+      ...state !== "omitted" && isFiniteNumber(detail.score) ? { accuracy: hundredths(detail.score) } : {}
+    });
+  }
+  if (words.length === 0) {
+    return null;
+  }
+  const scores = {};
+  for (const criterion of _nullishCoalesce(grade.criteria, () => ( []))) {
+    const dimension = DIMENSIONS.find((name) => name === criterion.name);
+    if (dimension !== void 0 && isFiniteNumber(criterion.score) && isFiniteNumber(criterion.maxScore) && criterion.maxScore > 0) {
+      scores[dimension] = hundredths(criterion.score / criterion.maxScore);
+    }
+  }
+  const kind = _optionalChain([grade, 'access', _23 => _23.grader, 'optionalAccess', _24 => _24.kind]);
+  return {
+    assessor: kind === "auto" || kind === "ai" || kind === "human" ? kind : "unknown",
+    scores,
+    words
+  };
+}
+function aiCoachingRequest(input) {
+  const { data, assessment, grade, learnerLocale } = input;
+  if (!aiSupports(data.type, "pronunciation-coaching") || !aiAllowedByContent(data, "pronunciation-coaching")) {
+    return null;
+  }
+  const item = data;
+  if (typeof item.referenceText !== "string" || typeof item.locale !== "string") {
+    return null;
+  }
+  const marks = assessment !== void 0 && assessment !== null ? marksThisText(item, assessment) ? fromAssessment(item, assessment) : null : grade !== void 0 && grade !== null ? fromGrade(grade) : null;
+  if (marks === null) {
+    return null;
+  }
+  const graded = grade !== void 0 && grade !== null && isFiniteNumber(grade.score) && isFiniteNumber(grade.maxScore) && typeof grade.passed === "boolean" ? { score: grade.score, maxScore: grade.maxScore, passed: grade.passed } : void 0;
+  return {
+    feature: "pronunciation-coaching",
+    facts: {
+      activityType: "read-aloud",
+      activityId: data.id,
+      title: data.title,
+      locale: item.locale,
+      referenceText: item.referenceText,
+      ...typeof item.instructions === "string" ? { instructions: item.instructions } : {},
+      ...marks
+    },
+    ...graded !== void 0 ? { grade: graded } : {},
+    ...learnerLocale !== void 0 ? { learnerLocale } : {}
+  };
+}
+var isRecord2 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var symbolKey = (symbol) => symbol.normalize("NFC").trim();
+function checkAiCoaching(raw, request) {
+  const read = readAiTextResult(raw);
+  if (!read.ok) {
+    return read;
+  }
+  const entries = raw.words;
+  const words = [];
+  if (entries !== void 0 && entries !== null) {
+    if (!Array.isArray(entries)) {
+      return { ok: false, refusal: "malformed" };
+    }
+    if (entries.length > AI_COACHING_MAX_WORDS) {
+      return { ok: false, refusal: "too-long" };
+    }
+    const facts = /* @__PURE__ */ new Map();
+    request.facts.words.forEach((fact, order) => {
+      if (fact.itemId !== void 0) {
+        facts.set(fact.itemId, { fact, order });
+      }
+    });
+    const seen = /* @__PURE__ */ new Set();
+    for (const entry of entries) {
+      if (!isRecord2(entry) || typeof entry.itemId !== "string" || typeof entry.tip !== "string") {
+        return { ok: false, refusal: "malformed" };
+      }
+      const tip = cleanText(entry.tip);
+      if (tip === "") {
+        return { ok: false, refusal: "malformed" };
+      }
+      if ([...tip].length > AI_COACHING_MAX_TIP_LENGTH) {
+        return { ok: false, refusal: "too-long" };
+      }
+      if (seen.has(entry.itemId)) {
+        return { ok: false, refusal: "malformed" };
+      }
+      seen.add(entry.itemId);
+      const found = facts.get(entry.itemId);
+      if (found === void 0 || found.fact.state !== "mispronounced" && found.fact.state !== "omitted") {
+        return { ok: false, refusal: "contradicts-marks" };
+      }
+      const sound = checkSound(entry.sound, found.fact);
+      if (sound !== void 0 && "refusal" in sound) {
+        return sound;
+      }
+      words.push({
+        itemId: entry.itemId,
+        word: found.fact.word,
+        tip,
+        ...sound !== void 0 ? { sound } : {},
+        order: found.order
+      });
+    }
+  }
+  const { text: text2, provenance, usage } = read.result;
+  return {
+    ok: true,
+    coaching: {
+      text: text2,
+      words: words.sort((a, b) => a.order - b.order).map(({ order: _order, ...word }) => word),
+      ...provenance !== void 0 ? { provenance } : {},
+      ...usage !== void 0 ? { usage } : {}
+    }
+  };
+}
+function checkSound(raw, fact) {
+  if (raw === void 0 || raw === null) {
+    return void 0;
+  }
+  if (!isRecord2(raw) || typeof raw.expected !== "string" || raw.heard !== void 0 && raw.heard !== null && typeof raw.heard !== "string") {
+    return { ok: false, refusal: "malformed" };
+  }
+  const heard = typeof raw.heard === "string" ? raw.heard : void 0;
+  if ([...raw.expected].length > MAX_SYMBOL_LENGTH || heard !== void 0 && [...heard].length > MAX_SYMBOL_LENGTH) {
+    return { ok: false, refusal: "too-long" };
+  }
+  const expected = symbolKey(raw.expected);
+  const reported = _optionalChain([fact, 'access', _25 => _25.sounds, 'optionalAccess', _26 => _26.find, 'call', _27 => _27((sound) => symbolKey(sound.symbol) === expected)]);
+  if (reported === void 0) {
+    return { ok: false, refusal: "contradicts-marks" };
+  }
+  if (heard === void 0) {
+    return { expected: reported.symbol };
+  }
+  const instead = _optionalChain([reported, 'access', _28 => _28.heardAs, 'optionalAccess', _29 => _29.find, 'call', _30 => _30(
+    (candidate) => symbolKey(candidate.symbol) === symbolKey(heard)
+  )]);
+  if (instead === void 0) {
+    return { ok: false, refusal: "contradicts-marks" };
+  }
+  return { expected: reported.symbol, heard: instead.symbol };
+}
+
+// src/authoring/index.ts
+function validateDraft(type, draft) {
+  return _chunk7THXD7ANcjs.withValidationScope.call(void 0, () => validateDraftInScope(type, draft));
+}
+function validateDraftInScope(type, draft) {
+  const descriptor = _chunk7THXD7ANcjs.getActivityTypeDescriptor.call(void 0, type);
+  if (descriptor === void 0) {
+    throw new (0, _chunk7THXD7ANcjs.UnknownActivityTypeError)(String(type));
+  }
+  const reported = _chunk7THXD7ANcjs.isRecord.call(void 0, draft) && _optionalChain([descriptor, 'access', _31 => _31.authoring, 'optionalAccess', _32 => _32.checkDraft]) !== void 0 ? descriptor.authoring.checkDraft(draft).map(normalise) : [];
+  const issues = [...reported];
+  const parsed = _chunk7THXD7ANcjs.readSchema.call(void 0, descriptor.schema, draft, `Activity type "${descriptor.type}"`, {
+    reportInput: true
+  });
+  if (!parsed.success) {
+    const covered = _chunk7THXD7ANcjs.coveredPathsOf.call(void 0, reported);
+    const reportedEmpty = /* @__PURE__ */ new Set();
+    for (const schemaIssue of parsed.issues) {
+      const path = schemaIssue.path.map(String);
+      if (covered.has(_chunk7THXD7ANcjs.pathKey.call(void 0, path))) {
+        continue;
+      }
+      if (path.length > 0 && _chunk7THXD7ANcjs.refusesEmpty.call(void 0, draft, schemaIssue)) {
+        const key = JSON.stringify(path);
+        if (!reportedEmpty.has(key)) {
+          reportedEmpty.add(key);
+          issues.push(
+            _chunk7THXD7ANcjs.issue.call(void 0, 
+              "null_not_allowed",
+              path,
+              typeof schemaIssue.path.at(-1) === "number" ? "This entry has no value. Remove it, or fill it in." : "This field cannot be null. Leave it out if it is optional, or give it a value."
+            )
+          );
+        }
+        continue;
+      }
+      issues.push({
+        path,
+        message: schemaIssue.message,
+        code: schemaIssue.code,
+        severity: "invalid"
+      });
+    }
+  }
+  if (parsed.success && issues.length === 0) {
+    return { status: "complete", data: parsed.data, issues };
+  }
+  const invalid = issues.some((found) => found.severity !== "incomplete");
+  return { status: invalid ? "invalid" : "incomplete", issues };
+}
+function createDraft(type, context) {
+  const descriptor = _chunk7THXD7ANcjs.getActivityTypeDescriptor.call(void 0, type);
+  if (descriptor === void 0) {
+    throw new (0, _chunk7THXD7ANcjs.UnknownActivityTypeError)(String(type));
+  }
+  const create = _optionalChain([descriptor, 'access', _33 => _33.authoring, 'optionalAccess', _34 => _34.createDraft]);
+  if (create === void 0) {
+    throw new Error(
+      `Activity type "${String(type)}" declares no authoring.createDraft, so there is no empty draft to create. Build the draft yourself; validateDraft works for every registered type.`
+    );
+  }
+  const issued = /* @__PURE__ */ new Set();
+  const newId = () => {
+    const id = context.newId();
+    if (typeof id !== "string" || id === "") {
+      throw new Error("createDraft: newId() must return a non-empty string.");
+    }
+    if (issued.has(id)) {
+      throw new Error(
+        `createDraft: newId() returned "${id}" twice. Ids within one draft must differ \u2014 two options sharing an id cannot be scored apart.`
+      );
+    }
+    issued.add(id);
+    return id;
+  };
+  return create({ newId });
+}
+function normalise(found) {
+  const documented = Object.hasOwn(_chunk7THXD7ANcjs.DRAFT_ISSUE_SEVERITY, found.code) ? _chunk7THXD7ANcjs.DRAFT_ISSUE_SEVERITY[found.code] : void 0;
+  return {
+    ...found,
+    path: found.path.map(String),
+    severity: _nullishCoalesce(documented, () => ( (found.severity === "incomplete" ? "incomplete" : "invalid")))
+  };
+}
+function critiqueDraft(type, draft) {
+  const descriptor = _chunk7THXD7ANcjs.getActivityTypeDescriptor.call(void 0, type);
+  if (descriptor === void 0) {
+    throw new (0, _chunk7THXD7ANcjs.UnknownActivityTypeError)(String(type));
+  }
+  const critique = _optionalChain([descriptor, 'access', _35 => _35.authoring, 'optionalAccess', _36 => _36.critique]);
+  if (!_chunk7THXD7ANcjs.isRecord.call(void 0, draft) || critique === void 0) {
+    return [];
+  }
+  return _chunk7THXD7ANcjs.withValidationScope.call(void 0, () => critique(draft)).map(_chunk7THXD7ANcjs.normaliseFinding);
+}
+
+// src/authoring/item-group.ts
+function createItemGroupDraft(context) {
+  const issued = /* @__PURE__ */ new Set();
+  const newId = () => {
+    const id = context.newId();
+    if (typeof id !== "string" || id === "") {
+      throw new Error("createItemGroupDraft: newId() must return a non-empty string.");
+    }
+    if (issued.has(id)) {
+      throw new Error(
+        `createItemGroupDraft: newId() returned "${id}" twice. Ids within one draft must differ.`
+      );
+    }
+    issued.add(id);
+    return id;
+  };
+  return {
+    schemaVersion: "1.0",
+    type: "item-group",
+    id: newId(),
+    stimulus: { id: newId(), kind: "text", body: "" },
+    items: []
+  };
+}
+function createInteractiveVideoDraft(context) {
+  const draft = createItemGroupDraft(context);
+  return {
+    ...draft,
+    stimulus: { id: draft.stimulus.id, kind: "video", media: { type: "video", url: "" } },
+    timeline: { cues: [] }
+  };
+}
+function critiqueItemGroupDraft(draft) {
+  if (!_chunk7THXD7ANcjs.isRecord.call(void 0, draft)) {
+    return [];
+  }
+  const items = Array.isArray(draft.items) ? draft.items : [];
+  return _chunk7THXD7ANcjs.withValidationScope.call(void 0, () => [
+    ...items.flatMap((item, index) => repathed(critiqueItem(item), ["items", index])),
+    ..._chunk7THXD7ANcjs.keyPositionFinding.call(void 0, items, ["items"])
+  ]);
+}
+function critiqueDrafts(entries) {
+  return _chunk7THXD7ANcjs.withValidationScope.call(void 0, () => [
+    ...entries.flatMap(
+      (entry, index) => repathed(
+        _chunk7THXD7ANcjs.isRecord.call(void 0, entry) && entry.type === "item-group" ? critiqueItemGroupDraft(entry) : critiqueItem(entry),
+        [index]
+      )
+    ),
+    ..._chunk7THXD7ANcjs.keyPositionFinding.call(void 0, entries, [])
+  ]);
+}
+function critiqueItem(item) {
+  if (!_chunk7THXD7ANcjs.isRecord.call(void 0, item) || typeof item.type !== "string") {
+    return [];
+  }
+  if (_chunk7THXD7ANcjs.getActivityTypeDescriptor.call(void 0, item.type) === void 0) {
+    return [];
+  }
+  return critiqueDraft(item.type, item);
+}
+var repathed = (findings, prefix) => findings.map((found) => ({ ...found, path: [...prefix.map(String), ...found.path] }));
+function validateItemGroupDraft(draft) {
+  return _chunk7THXD7ANcjs.withValidationScope.call(void 0, () => validateItemGroupDraftInScope(draft));
+}
+function validateItemGroupDraftInScope(draft) {
+  const issues = [];
+  if (!_chunk7THXD7ANcjs.isRecord.call(void 0, draft)) {
+    issues.push(
+      _chunk7THXD7ANcjs.issue.call(void 0, "ig_not_an_object", [], "A group must be an object with a stimulus and its items.")
+    );
+    return { status: "invalid", issues };
+  }
+  issues.push(...checkGroupIdentity(draft));
+  if (_chunk7THXD7ANcjs.isRecord.call(void 0, draft.stimulus)) {
+    issues.push(...checkStimulus(draft.stimulus));
+  } else if (_chunk7THXD7ANcjs.isUnset.call(void 0, draft.stimulus)) {
+    issues.push(
+      _chunk7THXD7ANcjs.issue.call(void 0, 
+        "ig_stimulus_required",
+        ["stimulus"],
+        "Add the passage, recording or image the questions are about."
+      )
+    );
+  }
+  issues.push(...checkItems(draft));
+  if (draft.timeline !== void 0 && draft.timeline !== null) {
+    issues.push(...checkTimeline(draft));
+  }
+  const captions = _chunk7THXD7ANcjs.groupCaptionsField.call(void 0, draft, (captionsUrl) => !_chunk7THXD7ANcjs.isUnwritten.call(void 0, captionsUrl));
+  if (captions !== void 0) {
+    issues.push(
+      _chunk7THXD7ANcjs.issue.call(void 0, 
+        "dc_captions_not_allowed",
+        ["stimulus", "media", captions],
+        _chunk7THXD7ANcjs.GROUP_CAPTIONS_REVEAL_DICTATION
+      )
+    );
+  }
+  const parsed = _chunkZWXQSKCXcjs.ItemGroupSchema.safeParse(draft, { reportInput: true });
+  if (!parsed.success) {
+    for (const schemaIssue of parsed.error.issues) {
+      const path = schemaIssue.path.map(String);
+      if (issues.some((known) => _chunk7THXD7ANcjs.covers.call(void 0, known.path, path))) {
+        continue;
+      }
+      if (path.length > 0 && _chunk7THXD7ANcjs.refusesEmpty.call(void 0, draft, schemaIssue)) {
+        issues.push(
+          _chunk7THXD7ANcjs.issue.call(void 0, 
+            "null_not_allowed",
+            path,
+            "This field cannot be null. Leave it out if it is optional, or give it a value."
+          )
+        );
+        continue;
+      }
+      issues.push({
+        path,
+        message: schemaIssue.message,
+        code: schemaIssue.code,
+        severity: "invalid"
+      });
+    }
+  }
+  const stored = _chunkZWXQSKCXcjs.validateItemGroup.call(void 0, draft);
+  if (issues.length === 0 && stored.success) {
+    return { status: "complete", data: stored.data, issues };
+  }
+  if (issues.length === 0) {
+    for (const error of stored.success ? [] : stored.errors) {
+      issues.push({ ...error, severity: "invalid" });
+    }
+  }
+  const invalid = issues.some((found) => found.severity !== "incomplete");
+  return { status: invalid ? "invalid" : "incomplete", issues };
+}
+function checkTimeline(draft) {
+  const issues = [];
+  const timeline = draft.timeline;
+  if (!_chunk7THXD7ANcjs.isRecord.call(void 0, timeline)) {
+    return issues;
+  }
+  const stimulus = _chunk7THXD7ANcjs.isRecord.call(void 0, draft.stimulus) ? draft.stimulus : void 0;
+  if (stimulus !== void 0 && !_chunk7THXD7ANcjs.isUnwritten.call(void 0, stimulus.kind) && stimulus.kind !== "video") {
+    issues.push(
+      _chunk7THXD7ANcjs.issue.call(void 0, 
+        "ig_timeline_stimulus_kind",
+        ["stimulus", "kind"],
+        "An interactive video needs a video: quizzes open at moments of it."
+      )
+    );
+  } else if (stimulus !== void 0 && _chunk7THXD7ANcjs.isRecord.call(void 0, stimulus.media) && !_chunk7THXD7ANcjs.isUnwritten.call(void 0, stimulus.media.type) && stimulus.media.type !== "video") {
+    issues.push(
+      _chunk7THXD7ANcjs.issue.call(void 0, 
+        "ig_timeline_stimulus_kind",
+        ["stimulus", "media", "type"],
+        "Upload a video file. An embedded player from another site cannot be paused when a quiz opens."
+      )
+    );
+  }
+  if (draft.shuffle === "within-group") {
+    issues.push(
+      _chunk7THXD7ANcjs.issue.call(void 0, 
+        "ig_timeline_shuffle",
+        ["shuffle"],
+        "The questions of an interactive video appear in the order their quizzes open, so they cannot be shuffled."
+      )
+    );
+  }
+  const items = Array.isArray(draft.items) ? draft.items : [];
+  const itemIndexById = /* @__PURE__ */ new Map();
+  items.forEach((item, index) => {
+    if (!_chunk7THXD7ANcjs.isRecord.call(void 0, item)) {
+      return;
+    }
+    if (typeof item.id === "string" && item.id !== "") {
+      itemIndexById.set(item.id, index);
+    }
+    const type = item.type;
+    if (typeof type === "string" && type !== "" && type !== "item-group" && !_chunkZWXQSKCXcjs.isInteractiveVideoItemType.call(void 0, type) && _chunk7THXD7ANcjs.getActivityTypeDescriptor.call(void 0, type) !== void 0) {
+      issues.push(
+        _chunk7THXD7ANcjs.issue.call(void 0, 
+          "ig_timeline_item_type",
+          ["items", index, "type"],
+          `An interactive video can hold ${_chunkZWXQSKCXcjs.INTERACTIVE_VIDEO_ITEM_TYPES.join(", ")} questions only.`
+        )
+      );
+    }
+    if (type === "dictation" && _chunk7THXD7ANcjs.isUnset.call(void 0, item.media)) {
+      issues.push(
+        _chunk7THXD7ANcjs.issue.call(void 0, 
+          "ig_timeline_dictation_media",
+          ["items", index, "media"],
+          "Add the recording this dictation plays: inside a video it cannot play the video."
+        )
+      );
+    }
+  });
+  const cues = Array.isArray(timeline.cues) ? timeline.cues : [];
+  const quizIds = /* @__PURE__ */ new Set();
+  const placed = /* @__PURE__ */ new Set();
+  cues.forEach((cue, cueIndex) => {
+    if (!_chunk7THXD7ANcjs.isRecord.call(void 0, cue)) {
+      return;
+    }
+    const at = (field, ...rest) => [
+      "timeline",
+      "cues",
+      cueIndex,
+      field,
+      ...rest
+    ];
+    if (_chunk7THXD7ANcjs.isMissingId.call(void 0, cue.id)) {
+      issues.push(_chunk7THXD7ANcjs.issue.call(void 0, "ig_timeline_quiz_id_required", at("id"), "This quiz has no id."));
+    } else if (typeof cue.id === "string") {
+      if (quizIds.has(cue.id)) {
+        issues.push(
+          _chunk7THXD7ANcjs.issue.call(void 0, "ig_timeline_quiz_id_duplicate", at("id"), `Two quizzes share the id "${cue.id}".`)
+        );
+      }
+      quizIds.add(cue.id);
+    }
+    if (_chunk7THXD7ANcjs.isUnset.call(void 0, cue.at)) {
+      issues.push(
+        _chunk7THXD7ANcjs.issue.call(void 0, 
+          "ig_timeline_quiz_time_required",
+          at("at"),
+          "Choose when in the video this quiz opens."
+        )
+      );
+    } else if (typeof cue.at !== "number" || !Number.isFinite(cue.at) || cue.at < 0) {
+      issues.push(
+        _chunk7THXD7ANcjs.issue.call(void 0, 
+          "ig_timeline_quiz_time_invalid",
+          at("at"),
+          "A quiz opens at a number of seconds, 0 or more."
+        )
+      );
+    }
+    if (_chunk7THXD7ANcjs.isUnset.call(void 0, cue.itemIds) || Array.isArray(cue.itemIds) && cue.itemIds.length === 0) {
+      issues.push(
+        _chunk7THXD7ANcjs.issue.call(void 0, "ig_timeline_quiz_empty", at("itemIds"), "Add at least one question to this quiz.")
+      );
+      return;
+    }
+    if (!Array.isArray(cue.itemIds)) {
+      return;
+    }
+    cue.itemIds.forEach((itemId, position) => {
+      if (typeof itemId !== "string") {
+        return;
+      }
+      if (!itemIndexById.has(itemId)) {
+        issues.push(
+          _chunk7THXD7ANcjs.issue.call(void 0, 
+            "ig_timeline_quiz_unknown_item",
+            at("itemIds", position),
+            `This quiz names a question that is not in the video ("${itemId}").`
+          )
+        );
+      } else if (placed.has(itemId)) {
+        issues.push(
+          _chunk7THXD7ANcjs.issue.call(void 0, 
+            "ig_timeline_item_duplicate",
+            at("itemIds", position),
+            "This question is already in a quiz: each question belongs to one quiz."
+          )
+        );
+      }
+      placed.add(itemId);
+    });
+  });
+  for (const [itemId, index] of itemIndexById) {
+    if (!placed.has(itemId)) {
+      issues.push(
+        _chunk7THXD7ANcjs.issue.call(void 0, 
+          "ig_timeline_item_unplaced",
+          ["items", index],
+          "Add this question to a quiz, or the video never shows it."
+        )
+      );
+    }
+  }
+  const chapters = Array.isArray(timeline.chapters) ? timeline.chapters : [];
+  let previousAt;
+  chapters.forEach((chapter, index) => {
+    if (!_chunk7THXD7ANcjs.isRecord.call(void 0, chapter)) {
+      return;
+    }
+    if (_chunk7THXD7ANcjs.isUnwritten.call(void 0, chapter.title)) {
+      issues.push(
+        _chunk7THXD7ANcjs.issue.call(void 0, 
+          "ig_timeline_chapter_title",
+          ["timeline", "chapters", index, "title"],
+          "Give this chapter a title."
+        )
+      );
+    }
+    if (typeof chapter.at === "number" && Number.isFinite(chapter.at)) {
+      if (previousAt !== void 0 && chapter.at <= previousAt) {
+        issues.push(
+          _chunk7THXD7ANcjs.issue.call(void 0, 
+            "ig_timeline_chapter_order",
+            ["timeline", "chapters", index, "at"],
+            "Chapters must start in order, each after the one before it."
+          )
+        );
+      }
+      previousAt = chapter.at;
+    }
+  });
+  return issues;
+}
+function checkGroupIdentity(draft) {
+  const issues = [];
+  if (draft.schemaVersion !== "1.0") {
+    issues.push(
+      _chunk7THXD7ANcjs.issue.call(void 0, 
+        "schema_version_invalid",
+        ["schemaVersion"],
+        'The draft must have schemaVersion "1.0". A draft from createItemGroupDraft has it.'
+      )
+    );
+  }
+  if (draft.type !== "item-group") {
+    issues.push(_chunk7THXD7ANcjs.issue.call(void 0, "type_mismatch", ["type"], `The draft's type must be "item-group".`));
+  }
+  if (_chunk7THXD7ANcjs.isMissingId.call(void 0, draft.id)) {
+    issues.push(_chunk7THXD7ANcjs.issue.call(void 0, "id_required", ["id"], "The group has no id."));
+  }
+  if (!_chunk7THXD7ANcjs.isUnset.call(void 0, draft.shuffle) && draft.shuffle !== "none" && draft.shuffle !== "within-group") {
+    issues.push(
+      _chunk7THXD7ANcjs.issue.call(void 0, 
+        "ig_shuffle_invalid",
+        ["shuffle"],
+        'Shuffling is either "none" or "within-group". Leave it out to keep the authored order.'
+      )
+    );
+  }
+  return issues;
+}
+var KINDS = /* @__PURE__ */ new Set(["text", "audio", "video", "image", "mixed"]);
+var MEDIA_FOR_KIND = {
+  audio: ["audio"],
+  video: ["video", "embed"],
+  image: ["image"],
+  mixed: ["audio", "video", "image", "embed"]
+};
+function checkStimulus(stimulus) {
+  const issues = [];
+  const at = (...rest) => ["stimulus", ...rest];
+  if (_chunk7THXD7ANcjs.isMissingId.call(void 0, stimulus.id)) {
+    issues.push(_chunk7THXD7ANcjs.issue.call(void 0, "ig_stimulus_id_required", at("id"), "The stimulus has no id."));
+  }
+  const kind = stimulus.kind;
+  if (_chunk7THXD7ANcjs.isUnwritten.call(void 0, kind)) {
+    issues.push(
+      _chunk7THXD7ANcjs.issue.call(void 0, 
+        "ig_stimulus_kind_required",
+        at("kind"),
+        "Choose what the questions are about: a text, a recording, a video, an image, or a mix."
+      )
+    );
+  } else if (typeof kind !== "string" || !KINDS.has(kind)) {
+    if (typeof kind === "string") {
+      issues.push(
+        _chunk7THXD7ANcjs.issue.call(void 0, 
+          "ig_stimulus_kind_invalid",
+          at("kind"),
+          `"${kind}" is not a stimulus kind. Use text, audio, video, image or mixed.`
+        )
+      );
+    }
+    if (_chunk7THXD7ANcjs.isRecord.call(void 0, stimulus.media)) {
+      issues.push(..._chunk7THXD7ANcjs.checkMedia.call(void 0, stimulus.media, at("media")));
+    }
+    return issues;
+  }
+  const hasBody = typeof stimulus.body === "string" && stimulus.body.trim() !== "";
+  const htmlPresent = !_chunk7THXD7ANcjs.isUnset.call(void 0, stimulus.bodyHtml);
+  if (!hasBody && (kind === "text" || kind === "mixed" || htmlPresent)) {
+    issues.push(
+      _chunk7THXD7ANcjs.issue.call(void 0, 
+        "ig_stimulus_body_required",
+        at("body"),
+        _chunk7THXD7ANcjs.isUnwritten.call(void 0, stimulus.bodyHtml) ? "Write the passage." : "Write the passage as plain text too. The rich-text version is shown only where a sanitiser is supplied."
+      )
+    );
+  }
+  if (kind !== "text" && _chunk7THXD7ANcjs.isUnset.call(void 0, stimulus.media)) {
+    issues.push(
+      _chunk7THXD7ANcjs.issue.call(void 0, "ig_stimulus_media_required", at("media"), "Add the recording, video or image.")
+    );
+  } else if (_chunk7THXD7ANcjs.isRecord.call(void 0, stimulus.media)) {
+    const allowed = MEDIA_FOR_KIND[kind];
+    const mediaType = stimulus.media.type;
+    if (allowed !== void 0 && typeof mediaType === "string" && !allowed.includes(mediaType)) {
+      issues.push(
+        _chunk7THXD7ANcjs.issue.call(void 0, 
+          "ig_stimulus_media_kind",
+          at("media", "type"),
+          `A "${kind}" stimulus cannot carry ${mediaType} media. Use ${allowed.join(" or ")}.`
+        )
+      );
+    }
+    issues.push(..._chunk7THXD7ANcjs.checkMedia.call(void 0, stimulus.media, at("media")));
+  }
+  return issues;
+}
+function checkItems(draft) {
+  const issues = [];
+  const items = _chunk7THXD7ANcjs.isUnset.call(void 0, draft.items) ? [] : draft.items;
+  if (!Array.isArray(items)) {
+    return issues;
+  }
+  if (items.length === 0) {
+    issues.push(
+      _chunk7THXD7ANcjs.issue.call(void 0, "ig_items_required", ["items"], "Add at least one question about this material.")
+    );
+    return issues;
+  }
+  const seen = /* @__PURE__ */ new Set();
+  const repeated = /* @__PURE__ */ new Set();
+  for (const [index, item] of items.entries()) {
+    if (!_chunk7THXD7ANcjs.isRecord.call(void 0, item)) {
+      continue;
+    }
+    const ordinal = index + 1;
+    if (_chunk7THXD7ANcjs.isMissingId.call(void 0, item.id)) {
+      issues.push(
+        _chunk7THXD7ANcjs.issue.call(void 0, "ig_item_id_required", ["items", index, "id"], `Question ${ordinal} has no id.`)
+      );
+    } else if (typeof item.id === "string") {
+      if (seen.has(item.id)) {
+        repeated.add(item.id);
+      }
+      seen.add(item.id);
+    }
+    if (item.type === "item-group") {
+      issues.push(
+        _chunk7THXD7ANcjs.issue.call(void 0, 
+          "ig_item_nested_group",
+          ["items", index, "type"],
+          "Groups do not nest: every item must be an activity."
+        )
+      );
+      continue;
+    }
+    if (_chunk7THXD7ANcjs.isUnwritten.call(void 0, item.type)) {
+      issues.push(
+        _chunk7THXD7ANcjs.issue.call(void 0, 
+          "ig_item_type_required",
+          ["items", index, "type"],
+          `Choose what kind of question ${ordinal} is.`
+        )
+      );
+      continue;
+    }
+    if (typeof item.type !== "string") {
+      continue;
+    }
+    let result;
+    try {
+      result = validateDraft(item.type, item);
+    } catch (error) {
+      if (!(error instanceof _chunk7THXD7ANcjs.UnknownActivityTypeError) || error.activityType !== item.type) {
+        throw error;
+      }
+      issues.push(
+        _chunk7THXD7ANcjs.issue.call(void 0, 
+          "ig_item_type_unknown",
+          ["items", index, "type"],
+          `"${item.type}" is not a registered activity type.`
+        )
+      );
+      continue;
+    }
+    for (const found of result.issues) {
+      issues.push({ ...found, path: ["items", String(index), ...found.path] });
+    }
+  }
+  for (const id of repeated) {
+    issues.push(
+      _chunk7THXD7ANcjs.issue.call(void 0, "ig_item_id_duplicate", ["items"], `More than one question has the id "${id}".`)
+    );
+  }
+  return issues;
+}
+
+// src/ai-critique.ts
+var AI_CRITIQUE_MAX_FINDINGS = 20;
+var AI_CRITIQUE_MAX_FIELD_LENGTH = 500;
+var KINDS2 = [
+  "ambiguous",
+  "second-answer",
+  "wrong-key",
+  "implausible-distractor",
+  "cue",
+  "level",
+  "language",
+  "sensitivity",
+  "other"
+];
+var NOT_WORDS = /* @__PURE__ */ new Set([
+  "id",
+  "type",
+  "schemaVersion",
+  "mode",
+  "scoringStrategy",
+  "presentation",
+  "locale",
+  "languageTarget",
+  "correctChoiceId",
+  "bankId",
+  "url",
+  "captionsUrl",
+  "match",
+  "playback",
+  "recording",
+  "scoring",
+  "ai",
+  "learningObjectives",
+  "hints",
+  "kind",
+  "timeline"
+]);
+function fieldsOf(value, path = []) {
+  if (typeof value === "string") {
+    return value.trim() === "" ? [] : [{ path, text: value }];
+  }
+  if (Array.isArray(value)) {
+    return value.flatMap((entry, index) => fieldsOf(entry, [...path, String(index)]));
+  }
+  if (typeof value === "object" && value !== null) {
+    return Object.entries(value).flatMap(
+      ([key, entry]) => NOT_WORDS.has(key) || key.endsWith("Html") ? [] : fieldsOf(entry, [...path, key])
+    );
+  }
+  return [];
+}
+function aiCritiqueRequest(input) {
+  const { type, draft, level, authorLocale } = input;
+  if (_chunk7THXD7ANcjs.getActivityTypeDescriptor.call(void 0, type) === void 0) {
+    throw new (0, _chunk7THXD7ANcjs.UnknownActivityTypeError)(String(type));
+  }
+  if (typeof draft !== "object" || draft === null || Array.isArray(draft)) {
+    return null;
+  }
+  const fields = fieldsOf(draft);
+  if (fields.length === 0) {
+    return null;
+  }
+  return {
+    feature: "item-critique",
+    facts: {
+      activityType: String(type),
+      item: draft,
+      fields,
+      findings: critiqueDraft(type, draft).map(({ path, code, message }) => ({
+        path,
+        code,
+        message
+      })),
+      ...level !== void 0 ? { level } : {}
+    },
+    ...authorLocale !== void 0 ? { authorLocale } : {}
+  };
+}
+var isRecord3 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var tooLong = (text2) => [...text2].length > AI_CRITIQUE_MAX_FIELD_LENGTH;
+function checkAiCritique(raw, request) {
+  if (!isRecord3(raw) || !Array.isArray(raw.findings)) {
+    return { ok: false, refusal: "malformed" };
+  }
+  if (raw.findings.length > AI_CRITIQUE_MAX_FINDINGS) {
+    return { ok: false, refusal: "too-long" };
+  }
+  const fields = new Map(request.facts.fields.map((field) => [JSON.stringify(field.path), field]));
+  const findings = [];
+  for (const entry of raw.findings) {
+    if (!isRecord3(entry) || !Array.isArray(entry.path) || !entry.path.every((segment) => typeof segment === "string" || typeof segment === "number") || typeof entry.kind !== "string" || !KINDS2.includes(entry.kind) || typeof entry.message !== "string" || entry.quote !== void 0 && entry.quote !== null && typeof entry.quote !== "string") {
+      return { ok: false, refusal: "malformed" };
+    }
+    const message = cleanText(entry.message);
+    const quote = typeof entry.quote === "string" ? cleanText(entry.quote) : void 0;
+    if (message === "" || quote === "") {
+      return { ok: false, refusal: "malformed" };
+    }
+    if (tooLong(message) || quote !== void 0 && tooLong(quote)) {
+      return { ok: false, refusal: "too-long" };
+    }
+    const field = fields.get(JSON.stringify(entry.path.map(String)));
+    if (field === void 0) {
+      return { ok: false, refusal: "contradicts-item" };
+    }
+    if (quote !== void 0 && !folded(field.text).chars.includes(needle(quote))) {
+      return { ok: false, refusal: "contradicts-item" };
+    }
+    findings.push({
+      path: field.path,
+      code: `ai_${entry.kind.replace(/-/g, "_")}`,
+      message,
+      severity: "advice",
+      ...quote !== void 0 ? { quote } : {}
+    });
+  }
+  const provenance = provenanceOf(raw.provenance);
+  const usage = usageOf(raw.usage);
+  return {
+    ok: true,
+    critique: {
+      findings,
+      ...provenance !== void 0 ? { provenance } : {},
+      ...usage !== void 0 ? { usage } : {}
+    }
+  };
+}
+
+// src/ai-drafts.ts
+var AI_DRAFTS_MAX_COUNT = 50;
+var AI_DRAFTS_MAX_REPAIRS = 3;
+var DRAFT_TYPES = [
+  "multiple-choice",
+  "fill-in-the-blanks",
+  "gap-select",
+  "dictation",
+  "read-aloud",
+  "written-response"
+];
+var isRecord4 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var text = (description) => ({ type: "string", description });
+var FEEDBACK = {
+  type: "object",
+  description: "Optional overall feedback, shown after answering.",
+  properties: {
+    correct: text("Shown when the learner passes."),
+    incorrect: text("Shown when the learner does not.")
+  }
+};
+var FIELDS = {
+  title: text(
+    "A short name for the item, shown to the learner above it. Never the answer, or any part of it."
+  ),
+  question: text("The question, as plain text."),
+  mode: {
+    type: "string",
+    enum: ["single", "multi"],
+    description: "`single`: exactly one option is right. `multi`: one or more are."
+  },
+  options: {
+    type: "array",
+    minItems: 2,
+    maxItems: 26,
+    items: {
+      type: "object",
+      required: ["text", "isCorrect"],
+      properties: {
+        text: text("The option as the learner reads it."),
+        isCorrect: { type: "boolean" },
+        feedback: text("Why this option is right or wrong, shown after answering.")
+      }
+    }
+  },
+  passage: text(
+    "The passage as plain text, with {{1}}, {{2}}, \u2026 where each gap goes, numbered in the order they appear."
+  ),
+  blanks: {
+    type: "array",
+    minItems: 1,
+    description: "One per gap, in the order the gaps appear: the first is {{1}}.",
+    items: {
+      type: "object",
+      required: ["acceptedAnswers"],
+      properties: {
+        acceptedAnswers: {
+          type: "array",
+          minItems: 1,
+          items: { type: "string" },
+          description: "Every answer that is right, spelled as a learner would type it."
+        },
+        hint: text("Optional. Helps without giving the answer or any of its words.")
+      }
+    }
+  },
+  gaps: {
+    type: "array",
+    minItems: 1,
+    description: "One per gap, in the order the gaps appear: the first is {{1}}.",
+    items: {
+      type: "object",
+      required: ["choices"],
+      properties: {
+        choices: {
+          type: "array",
+          minItems: 2,
+          description: "What the learner chooses from. Exactly one is right.",
+          items: {
+            type: "object",
+            required: ["text", "isCorrect"],
+            properties: { text: text("A choice."), isCorrect: { type: "boolean" } }
+          }
+        }
+      }
+    }
+  },
+  transcript: text(
+    "What the learner hears and types: words from the source, as they are said there."
+  ),
+  referenceText: text("What the learner reads aloud: a sentence or two from the source."),
+  instructions: text("Optional. How to read it, shown to the learner."),
+  prompt: text("The writing task, as plain text."),
+  minWords: { type: "integer", minimum: 0 },
+  maxWords: { type: "integer", minimum: 1 },
+  rubric: {
+    type: "object",
+    description: "Optional. What the writing is assessed on; every criterion is weighted equally.",
+    properties: {
+      criteria: {
+        type: "array",
+        minItems: 1,
+        items: {
+          type: "object",
+          required: ["name"],
+          properties: { name: text("A short name."), description: text("What it looks for.") }
+        }
+      }
+    }
+  },
+  feedback: FEEDBACK
+};
+var WRITES = {
+  "multiple-choice": ["title", "question", "mode", "options", "feedback"],
+  "fill-in-the-blanks": ["title", "passage", "blanks", "feedback"],
+  "gap-select": ["title", "passage", "gaps", "feedback"],
+  dictation: ["title", "transcript", "feedback"],
+  "read-aloud": ["title", "referenceText", "instructions", "feedback"],
+  "written-response": ["title", "prompt", "minWords", "maxWords", "rubric"]
+};
+function itemShape(types, captions) {
+  const properties = {
+    type: {
+      type: "string",
+      enum: [...types],
+      description: `The item's type, and the fields it fills. ${types.map((type) => `${type}: ${WRITES[type].filter((name) => name !== "title").join(", ")}`).join(". ")}.`
+    }
+  };
+  for (const type of types) {
+    for (const name of WRITES[type]) {
+      properties[name] = FIELDS[name];
+    }
+  }
+  if (captions) {
+    properties.caption = {
+      type: "integer",
+      minimum: 0,
+      description: "The index of the caption the item is about. It opens when that caption ends."
+    };
+  }
+  return {
+    type: "object",
+    required: captions ? ["type", "title", "caption"] : ["type", "title"],
+    properties
+  };
+}
+function replyShape(types, captions, max, exactly) {
+  return {
+    type: "object",
+    required: ["drafts"],
+    properties: {
+      drafts: {
+        type: "array",
+        ...exactly !== void 0 ? { minItems: exactly, maxItems: exactly } : { maxItems: max },
+        items: itemShape(types, captions)
+      }
+    }
+  };
+}
+function aiDraftsRequest(input) {
+  const { types, source, count, locale, level, instructions, settings } = input;
+  if (!Array.isArray(types) || types.length === 0 || new Set(types).size !== types.length || !types.every((type) => DRAFT_TYPES.includes(type))) {
+    throw new RangeError(
+      `aiDraftsRequest: types must be one or more of ${DRAFT_TYPES.join(", ")}, each once, in the author's order.`
+    );
+  }
+  if (count !== void 0 && (!Number.isInteger(count) || count < 1 || count > AI_DRAFTS_MAX_COUNT)) {
+    throw new RangeError(
+      `aiDraftsRequest: count must be a whole number from 1 to ${AI_DRAFTS_MAX_COUNT}, or left out, not ${String(count)}.`
+    );
+  }
+  let facts;
+  if (source.kind === "captions") {
+    const captions = (Array.isArray(source.cues) ? source.cues : []).flatMap(
+      (cue, index) => isRecord4(cue) && typeof cue.text === "string" && cue.text.trim() !== "" && Number.isFinite(cue.start) && Number.isFinite(cue.end) ? [{ index, start: cue.start, end: cue.end, text: cue.text }] : []
+    );
+    if (captions.length === 0) {
+      return null;
+    }
+    facts = { kind: "captions", captions };
+  } else {
+    if (typeof source.text !== "string" || source.text.trim() === "") {
+      return null;
+    }
+    facts = { kind: source.kind, text: source.text };
+  }
+  return {
+    feature: "draft-generation",
+    facts: {
+      activityTypes: [...types],
+      source: facts,
+      ...count !== void 0 ? { count } : {},
+      ...locale !== void 0 ? { locale } : {},
+      ...level !== void 0 ? { level } : {},
+      ...instructions !== void 0 ? { instructions } : {}
+    },
+    shape: replyShape(types, facts.kind === "captions", _nullishCoalesce(count, () => ( AI_DRAFTS_MAX_COUNT))),
+    ...settings !== void 0 ? { settings } : {}
+  };
+}
+var stringOf = (value) => typeof value === "string" ? value : "";
+var listOf2 = (value) => Array.isArray(value) ? value : [];
+var written = (value) => typeof value === "string" && value.trim() !== "" ? value : void 0;
+function feedbackOf(entry) {
+  if (!isRecord4(entry.feedback)) {
+    return {};
+  }
+  const correct = written(entry.feedback.correct);
+  const incorrect = written(entry.feedback.incorrect);
+  return correct === void 0 && incorrect === void 0 ? {} : {
+    feedback: {
+      ...correct !== void 0 ? { correct } : {},
+      ...incorrect !== void 0 ? { incorrect } : {}
+    }
+  };
+}
+function contentOf(type, entry, newId) {
+  switch (type) {
+    case "multiple-choice":
+      return {
+        question: stringOf(entry.question),
+        ...typeof entry.mode === "string" ? { mode: entry.mode } : {},
+        options: listOf2(entry.options).map((option) => {
+          const fields = isRecord4(option) ? option : {};
+          const feedback = written(fields.feedback);
+          return {
+            id: newId(),
+            text: stringOf(fields.text),
+            isCorrect: fields.isCorrect === true,
+            ...feedback !== void 0 ? { feedback } : {}
+          };
+        }),
+        ...feedbackOf(entry)
+      };
+    case "fill-in-the-blanks":
+      return {
+        passage: stringOf(entry.passage),
+        blanks: listOf2(entry.blanks).map((blank, index) => {
+          const fields = isRecord4(blank) ? blank : {};
+          const hint = written(fields.hint);
+          return {
+            id: String(index + 1),
+            acceptedAnswers: listOf2(fields.acceptedAnswers).filter(
+              (answer) => typeof answer === "string"
+            ),
+            ...hint !== void 0 ? { hint } : {}
+          };
+        }),
+        ...feedbackOf(entry)
+      };
+    case "gap-select":
+      return {
+        passage: stringOf(entry.passage),
+        gaps: listOf2(entry.gaps).map((gap, index) => {
+          const marked = listOf2(isRecord4(gap) ? gap.choices : void 0);
+          const choices = marked.map((choice) => ({
+            id: newId(),
+            text: stringOf(isRecord4(choice) ? choice.text : void 0)
+          }));
+          const right = marked.flatMap(
+            (choice, at) => isRecord4(choice) && choice.isCorrect === true ? [at] : []
+          );
+          return {
+            id: String(index + 1),
+            choices,
+            correctChoiceId: right.length === 1 ? _optionalChain([choices, 'access', _37 => _37[right[0]], 'optionalAccess', _38 => _38.id]) : ""
+          };
+        }),
+        ...feedbackOf(entry)
+      };
+    case "dictation":
+      return { transcript: stringOf(entry.transcript), ...feedbackOf(entry) };
+    case "read-aloud": {
+      const instructions = written(entry.instructions);
+      return {
+        referenceText: stringOf(entry.referenceText),
+        ...instructions !== void 0 ? { instructions } : {},
+        ...feedbackOf(entry)
+      };
+    }
+    default: {
+      const criteria = listOf2(isRecord4(entry.rubric) ? entry.rubric.criteria : void 0);
+      return {
+        prompt: stringOf(entry.prompt),
+        ...entry.minWords !== void 0 ? { minWords: entry.minWords } : {},
+        ...entry.maxWords !== void 0 ? { maxWords: entry.maxWords } : {},
+        ...criteria.length > 0 ? {
+          rubric: {
+            criteria: criteria.map((criterion) => {
+              const fields = isRecord4(criterion) ? criterion : {};
+              const description = written(fields.description);
+              return {
+                name: stringOf(fields.name),
+                ...description !== void 0 ? { description } : {},
+                weight: 1
+              };
+            })
+          }
+        } : {}
+      };
+    }
+  }
+}
+function startOf(type) {
+  switch (type) {
+    case "multiple-choice":
+    case "fill-in-the-blanks":
+    case "gap-select":
+      return { scoringStrategy: "all-or-nothing" };
+    case "read-aloud":
+      return { recording: { maxSeconds: 0 }, scoring: { dimensions: [] } };
+    default:
+      return {};
+  }
+}
+function draftFrom(type, entry, id, newId, request) {
+  const locale = request.facts.locale;
+  return {
+    ...startOf(type),
+    ...locale !== void 0 ? { locale } : {},
+    ..._optionalChain([request, 'access', _39 => _39.settings, 'optionalAccess', _40 => _40[type]]),
+    title: stringOf(entry.title),
+    ...contentOf(type, entry, newId),
+    schemaVersion: "1.0",
+    type,
+    id
+  };
+}
+function idSource(newId, caller) {
+  const issued = /* @__PURE__ */ new Set();
+  return () => {
+    const id = newId();
+    if (typeof id !== "string" || id === "") {
+      throw new Error(`${caller}: newId() must return a non-empty string.`);
+    }
+    if (issued.has(id)) {
+      throw new Error(
+        `${caller}: newId() returned "${id}" twice. Ids must differ \u2014 two options sharing an id cannot be scored apart.`
+      );
+    }
+    issued.add(id);
+    return id;
+  };
+}
+function inAuthorsOrder(drafts, types) {
+  return [...drafts].sort(
+    (a, b) => types.indexOf(a.type) - types.indexOf(b.type) || a.index - b.index
+  );
+}
+function check(raw, request, newId, keep = []) {
+  const types = request.facts.activityTypes;
+  if (!isRecord4(raw) || !Array.isArray(raw.drafts) || !raw.drafts.every((entry) => isRecord4(entry) && types.includes(entry.type))) {
+    return { ok: false, refusal: "malformed" };
+  }
+  const entries = raw.drafts;
+  const repair = request.repair;
+  const most = _nullishCoalesce(request.facts.count, () => ( AI_DRAFTS_MAX_COUNT));
+  if (repair !== void 0 ? entries.length !== repair.length : entries.length > most) {
+    return { ok: false, refusal: repair !== void 0 ? "malformed" : "too-long" };
+  }
+  const source = request.facts.source;
+  const drafts = entries.map((entry, position) => {
+    const type = entry.type;
+    const draft = draftFrom(type, entry, _nullishCoalesce(keep[position], () => ( newId())), newId, request);
+    const caption = source.kind === "captions" && Number.isInteger(entry.caption) ? source.captions.find((one) => one.index === entry.caption) : void 0;
+    const said = _chunk7THXD7ANcjs.fold.call(void 0, stringOf(entry.transcript));
+    const clip = type === "dictation" && caption !== void 0 && _chunk7THXD7ANcjs.containsWords.call(void 0, _chunk7THXD7ANcjs.fold.call(void 0, caption.text), said) ? { start: caption.start, end: caption.end } : void 0;
+    return {
+      index: repair !== void 0 ? _optionalChain([repair, 'access', _41 => _41[position], 'optionalAccess', _42 => _42.index]) : position,
+      type,
+      draft,
+      validation: validateDraft(type, draft),
+      findings: critiqueDraft(type, draft),
+      ...caption !== void 0 ? { at: caption.end } : {},
+      ...clip !== void 0 ? { clip } : {},
+      generated: entry
+    };
+  });
+  const ordered = inAuthorsOrder(drafts, types);
+  const provenance = provenanceOf(raw.provenance);
+  const usage = usageOf(raw.usage);
+  return {
+    ok: true,
+    drafts: {
+      drafts: ordered,
+      findings: _chunk7THXD7ANcjs.keyPositionFinding.call(void 0, 
+        ordered.map((one) => one.draft),
+        []
+      ),
+      ...provenance !== void 0 ? { provenance } : {},
+      ...usage !== void 0 ? { usage } : {}
+    }
+  };
+}
+function checkAiDrafts(raw, request, options) {
+  return check(raw, request, idSource(options.newId, "checkAiDrafts"));
+}
+function pathForModel(type, problem) {
+  const { path, code } = problem;
+  if (type === "gap-select" && path.length === 3 && path[0] === "gaps" && path[2] === "correctChoiceId") {
+    return ["gaps", path[1], "choices"];
+  }
+  return code === "ra_text_long_for_time" ? ["referenceText"] : [...path];
+}
+function problemsOf(one) {
+  const writes = WRITES[one.type];
+  return [
+    ...one.validation.issues.map(
+      (found) => ({
+        path: found.path,
+        code: found.code,
+        message: found.message,
+        severity: found.severity
+      })
+    ),
+    ...one.findings.filter((found) => found.severity === "warning").map(
+      (found) => ({
+        path: found.path,
+        code: found.code,
+        message: found.message,
+        severity: "warning"
+      })
+    )
+  ].map((problem) => ({ ...problem, path: pathForModel(one.type, problem) })).filter((problem) => writes.includes(problem.path[0]));
+}
+function aiDraftsRepairRequest(request, drafts) {
+  const list = "drafts" in drafts ? drafts.drafts : drafts;
+  const repair = list.flatMap((one) => {
+    const problems = problemsOf(one);
+    return problems.length === 0 ? [] : [{ index: one.index, draft: one.generated, problems }];
+  });
+  if (repair.length === 0) {
+    return null;
+  }
+  const { repair: _previous, ...first } = request;
+  return {
+    ...first,
+    shape: replyShape(
+      request.facts.activityTypes,
+      request.facts.source.kind === "captions",
+      repair.length,
+      repair.length
+    ),
+    repair
+  };
+}
+var RANK = { complete: 2, incomplete: 1, invalid: 0 };
+function noWorse(repaired, before) {
+  const warnings = (one) => one.findings.filter((found) => found.severity === "warning").length;
+  const now = RANK[repaired.validation.status];
+  const was = RANK[before.validation.status];
+  return now > was || now === was && warnings(repaired) <= warnings(before);
+}
+async function generateDrafts(input) {
+  const { request, port, newId } = input;
+  const repairs = _nullishCoalesce(input.repairs, () => ( 1));
+  if (!Number.isInteger(repairs) || repairs < 0 || repairs > AI_DRAFTS_MAX_REPAIRS) {
+    throw new RangeError(
+      `generateDrafts: repairs must be a whole number from 0 to ${AI_DRAFTS_MAX_REPAIRS}, not ${String(repairs)}.`
+    );
+  }
+  const calls = [];
+  const ids = idSource(newId, "generateDrafts");
+  const ask = async (asked, keep) => {
+    let raw;
+    try {
+      raw = await port(asked);
+    } catch (error) {
+      calls.push({ ok: false, error: error instanceof Error ? error.message : String(error) });
+      return void 0;
+    }
+    const checked = check(raw, asked, ids, keep);
+    if (!checked.ok) {
+      calls.push({ ok: false, refusal: checked.refusal });
+      return void 0;
+    }
+    const { provenance, usage } = checked.drafts;
+    calls.push({
+      ok: true,
+      ...provenance !== void 0 ? { provenance } : {},
+      ...usage !== void 0 ? { usage } : {}
+    });
+    return checked.drafts;
+  };
+  const first = await ask(request, []);
+  if (first === void 0) {
+    return { drafts: [], findings: [], calls };
+  }
+  let current = first.drafts;
+  for (let pass = 0; pass < repairs; pass += 1) {
+    const repairRequest = aiDraftsRepairRequest(request, current);
+    if (repairRequest === null) {
+      break;
+    }
+    const keep = (_nullishCoalesce(repairRequest.repair, () => ( []))).map((wanted) => {
+      const before = current.find((one) => one.index === wanted.index);
+      return typeof _optionalChain([before, 'optionalAccess', _43 => _43.draft, 'access', _44 => _44.id]) === "string" ? before.draft.id : void 0;
+    });
+    const repaired = await ask(repairRequest, keep);
+    if (repaired === void 0) {
+      break;
+    }
+    current = current.map((before) => {
+      const after = repaired.drafts.find((one) => one.index === before.index);
+      return after !== void 0 && noWorse(after, before) ? after : before;
+    });
+  }
+  return {
+    drafts: current,
+    findings: _chunk7THXD7ANcjs.keyPositionFinding.call(void 0, 
+      current.map((one) => one.draft),
+      []
+    ),
+    calls
+  };
+}
+function sourceText(request) {
+  const source = request.facts.source;
+  return source.kind === "captions" ? source.captions.map((caption) => caption.text).join("\n") : source.text;
+}
+function interactiveVideoFromDrafts(input) {
+  const { request, drafts, video, durationSeconds, title } = input;
+  const ids = idSource(input.newId, "interactiveVideoFromDrafts");
+  const types = request.facts.activityTypes;
+  const list = "drafts" in drafts ? drafts.drafts : drafts;
+  const end = typeof durationSeconds === "number" && Number.isFinite(durationSeconds) && durationSeconds >= 0 ? durationSeconds : void 0;
+  const placed = list.map((one) => ({ one, at: _nullishCoalesce(one.at, () => ( end)) }));
+  const ordered = [...placed].sort(
+    (a, b) => (_nullishCoalesce(a.at, () => ( Number.POSITIVE_INFINITY))) - (_nullishCoalesce(b.at, () => ( Number.POSITIVE_INFINITY))) || types.indexOf(a.one.type) - types.indexOf(b.one.type) || a.one.index - b.one.index
+  );
+  const cues = [];
+  for (const { one, at } of ordered) {
+    const itemId = String(one.draft.id);
+    const last = cues[cues.length - 1];
+    if (last !== void 0 && last.at === at) {
+      last.itemIds.push(itemId);
+    } else {
+      cues.push({ id: ids(), ...at !== void 0 ? { at } : {}, itemIds: [itemId] });
+    }
+  }
+  const group = {
+    schemaVersion: "1.0",
+    type: "item-group",
+    id: ids(),
+    ...title !== void 0 ? { title } : {},
+    stimulus: { id: ids(), kind: "video", media: video, transcript: sourceText(request) },
+    items: ordered.map(({ one }) => one.draft),
+    timeline: { cues }
+  };
+  return {
+    group,
+    validation: validateItemGroupDraft(group),
+    findings: critiqueItemGroupDraft(group)
+  };
+}
+
+// src/ai-writing.ts
+var AI_WRITING_MAX_CORRECTIONS = 20;
+var AI_WRITING_MAX_FIELD_LENGTH = 500;
+var MAX_TAG_LENGTH = 40;
+function aiWritingFeedbackRequest(input) {
+  const { data, response, learnerLocale } = input;
+  if (!aiSupports(data.type, "writing-feedback") || !aiAllowedByContent(data, "writing-feedback") || data.redacted === true) {
+    return null;
+  }
+  const text2 = _optionalChain([response, 'optionalAccess', _45 => _45.type]) === "written-response" ? response.text : "";
+  if (typeof text2 !== "string" || text2.trim() === "") {
+    return null;
+  }
+  const item = data;
+  const wordCount = _chunk7THXD7ANcjs.countWords.call(void 0, text2);
+  const minWords = typeof item.minWords === "number" ? item.minWords : 0;
+  const maxWords = typeof item.maxWords === "number" ? item.maxWords : Number.POSITIVE_INFINITY;
+  const criteria = Array.isArray(_optionalChain([item, 'access', _46 => _46.rubric, 'optionalAccess', _47 => _47.criteria])) ? item.rubric.criteria : null;
+  const rubric = criteria === null || criteria.length === 0 ? null : criteria.map((criterion) => ({
+    name: criterion.name,
+    ...typeof criterion.description === "string" ? { description: criterion.description } : {},
+    weight: criterion.weight
+  }));
+  const previousFeedback = [..._nullishCoalesce(input.previousFeedback, () => ( []))];
+  return {
+    feature: "writing-feedback",
+    facts: {
+      activityType: "written-response",
+      activityId: data.id,
+      title: data.title,
+      ...typeof data.locale === "string" ? { locale: data.locale } : {},
+      prompt: typeof item.prompt === "string" ? item.prompt : "",
+      text: text2,
+      wordCount,
+      minWords,
+      maxWords,
+      withinWordBounds: wordCount >= minWords && wordCount <= maxWords,
+      rubric,
+      ...typeof item.languageTarget === "string" ? { languageTarget: item.languageTarget } : {}
+    },
+    draftNumber: previousFeedback.length + 1,
+    previousFeedback,
+    ...learnerLocale !== void 0 ? { learnerLocale } : {}
+  };
+}
+function anchor(draft, quote, claimed, taken) {
+  const sought = needle(quote);
+  if (sought === "") {
+    return null;
+  }
+  if (claimed !== void 0) {
+    const { start, end } = claimed;
+    if (!Number.isSafeInteger(start) || !Number.isSafeInteger(end) || start < 0 || end > draft.text.length || start >= end) {
+      return null;
+    }
+    const span = draft.text.slice(start, end);
+    if (needle(span) !== sought) {
+      return null;
+    }
+    const lead = span.length - span.trimStart().length;
+    const trail = span.length - span.trimEnd().length;
+    return { start: start + lead, end: end - trail };
+  }
+  let first = null;
+  for (let at = draft.chars.indexOf(sought); at !== -1; at = draft.chars.indexOf(sought, at + 1)) {
+    const start = draft.from[at];
+    const end = draft.from[at + sought.length - 1] + 1;
+    const found = { start, end };
+    first ??= found;
+    const key = `${start}:${end}`;
+    if (!taken.has(key)) {
+      taken.add(key);
+      return found;
+    }
+  }
+  return first;
+}
+function textField(value, max) {
+  if (value === void 0 || value === null) {
+    return { ok: true, value: void 0 };
+  }
+  if (typeof value !== "string") {
+    return { ok: false, refusal: "malformed" };
+  }
+  const cleaned = cleanText(value);
+  if ([...cleaned].length > max) {
+    return { ok: false, refusal: "too-long" };
+  }
+  return { ok: true, value: cleaned === "" ? void 0 : cleaned };
+}
+var isRecord5 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+function checkCorrections(raw, text2) {
+  if (raw === void 0 || raw === null) {
+    return { ok: true, corrections: [] };
+  }
+  if (!Array.isArray(raw)) {
+    return { ok: false, refusal: "malformed" };
+  }
+  if (raw.length > AI_WRITING_MAX_CORRECTIONS) {
+    return { ok: false, refusal: "too-long" };
+  }
+  const draft = { text: text2, ...folded(text2) };
+  const taken = /* @__PURE__ */ new Set();
+  const corrections = [];
+  for (const entry of raw) {
+    if (!isRecord5(entry) || typeof entry.original !== "string") {
+      return { ok: false, refusal: "malformed" };
+    }
+    if (typeof entry.corrected !== "string") {
+      return { ok: false, refusal: "malformed" };
+    }
+    if ([...entry.original].length > AI_WRITING_MAX_FIELD_LENGTH || [...entry.corrected].length > AI_WRITING_MAX_FIELD_LENGTH) {
+      return { ok: false, refusal: "too-long" };
+    }
+    if (needle(entry.original) === needle(entry.corrected)) {
+      return { ok: false, refusal: "malformed" };
+    }
+    const explanation = textField(entry.explanation, AI_WRITING_MAX_FIELD_LENGTH);
+    const category = textField(entry.category, MAX_TAG_LENGTH);
+    if (!explanation.ok) {
+      return explanation;
+    }
+    if (!category.ok) {
+      return category;
+    }
+    let claimed;
+    if (entry.range !== void 0 && entry.range !== null) {
+      if (!isRecord5(entry.range)) {
+        return { ok: false, refusal: "malformed" };
+      }
+      claimed = { start: entry.range.start, end: entry.range.end };
+    }
+    const at = anchor(draft, entry.original, claimed, taken);
+    if (at === null) {
+      return { ok: false, refusal: "misquotes-answer" };
+    }
+    corrections.push({
+      original: text2.slice(at.start, at.end),
+      corrected: cleanText(entry.corrected),
+      ...explanation.value !== void 0 ? { explanation: explanation.value } : {},
+      ...category.value !== void 0 ? { category: category.value } : {},
+      range: at
+    });
+  }
+  return { ok: true, corrections };
+}
+function isJudgedScore(score2, maxScore) {
+  if (score2 === void 0) {
+    return maxScore === void 0 || typeof maxScore === "number" && maxScore > 0;
+  }
+  const max = _nullishCoalesce(maxScore, () => ( 1));
+  return typeof score2 === "number" && typeof max === "number" && Number.isFinite(score2) && Number.isFinite(max) && max > 0 && score2 >= 0 && score2 - max <= max * 1e-9;
+}
+function checkCriteria(raw, rubric) {
+  if (raw === void 0 || raw === null) {
+    return { ok: true, criteria: [] };
+  }
+  if (!Array.isArray(raw)) {
+    return { ok: false, refusal: "malformed" };
+  }
+  if (raw.length === 0) {
+    return { ok: true, criteria: [] };
+  }
+  if (rubric === null) {
+    return { ok: false, refusal: "malformed" };
+  }
+  const weights = new Map(rubric.map((criterion) => [criterion.name, criterion.weight]));
+  const seen = /* @__PURE__ */ new Set();
+  const criteria = [];
+  for (const entry of raw) {
+    if (!isRecord5(entry) || typeof entry.name !== "string") {
+      return { ok: false, refusal: "malformed" };
+    }
+    const weight = weights.get(entry.name);
+    if (weight === void 0 || seen.has(entry.name)) {
+      return { ok: false, refusal: "malformed" };
+    }
+    seen.add(entry.name);
+    if (!isJudgedScore(entry.score, entry.maxScore)) {
+      return { ok: false, refusal: "malformed" };
+    }
+    if (entry.notApplicable !== void 0 && typeof entry.notApplicable !== "boolean") {
+      return { ok: false, refusal: "malformed" };
+    }
+    const band = textField(entry.band, MAX_TAG_LENGTH);
+    const comment = textField(entry.comment, AI_WRITING_MAX_FIELD_LENGTH);
+    if (!band.ok) {
+      return band;
+    }
+    if (!comment.ok) {
+      return comment;
+    }
+    criteria.push({
+      name: entry.name,
+      ...typeof entry.score === "number" ? { score: entry.score } : {},
+      ...typeof entry.maxScore === "number" ? { maxScore: entry.maxScore } : {},
+      ...band.value !== void 0 ? { band: band.value } : {},
+      ...comment.value !== void 0 ? { comment: comment.value } : {},
+      ...entry.notApplicable === true ? { notApplicable: true } : {},
+      weight
+    });
+  }
+  return { ok: true, criteria };
+}
+function checkAiWritingFeedback(raw, request) {
+  const read = readAiTextResult(raw);
+  if (!read.ok) {
+    return read;
+  }
+  const record = raw;
+  const corrections = checkCorrections(record.corrections, request.facts.text);
+  if (!corrections.ok) {
+    return corrections;
+  }
+  const rubric = request.facts.rubric;
+  const criteria = checkCriteria(record.criteria, rubric);
+  if (!criteria.ok) {
+    return criteria;
+  }
+  let indicativeScore = null;
+  const judged = new Set(criteria.criteria.map((criterion) => criterion.name));
+  if (_optionalChain([rubric, 'optionalAccess', _48 => _48.every, 'call', _49 => _49((criterion) => judged.has(criterion.name))])) {
+    const grade = _chunk4YANYTFNcjs.gradeFromRubric.call(void 0, criteria.criteria);
+    indicativeScore = "unscorable" in grade ? null : grade.score;
+  }
+  const { text: text2, provenance, usage } = read.result;
+  return {
+    ok: true,
+    feedback: {
+      text: text2,
+      corrections: corrections.corrections,
+      criteria: criteria.criteria,
+      indicativeScore,
+      ...provenance !== void 0 ? { provenance } : {},
+      ...usage !== void 0 ? { usage } : {}
+    }
+  };
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.AI_EXPLANATION_TYPES = AI_EXPLANATION_TYPES; exports.AI_HINT_TYPES = AI_HINT_TYPES; exports.AI_TEXT_MAX_LENGTH = AI_TEXT_MAX_LENGTH; exports.aiSupports = aiSupports; exports.aiAllowedByContent = aiAllowedByContent; exports.aiGradeOf = aiGradeOf; exports.buildAiFacts = buildAiFacts; exports.aiExplanationRequest = aiExplanationRequest; exports.aiHintRequest = aiHintRequest; exports.readAiTextResult = readAiTextResult; exports.checkAiExplanation = checkAiExplanation; exports.checkAiHint = checkAiHint; exports.hintRevealsAnswer = hintRevealsAnswer; exports.AI_COACHING_MAX_WORDS = AI_COACHING_MAX_WORDS; exports.AI_COACHING_MAX_TIP_LENGTH = AI_COACHING_MAX_TIP_LENGTH; exports.aiCoachingRequest = aiCoachingRequest; exports.checkAiCoaching = checkAiCoaching; exports.createItemGroupDraft = createItemGroupDraft; exports.createInteractiveVideoDraft = createInteractiveVideoDraft; exports.critiqueItemGroupDraft = critiqueItemGroupDraft; exports.critiqueDrafts = critiqueDrafts; exports.validateItemGroupDraft = validateItemGroupDraft; exports.validateDraft = validateDraft; exports.createDraft = createDraft; exports.critiqueDraft = critiqueDraft; exports.AI_CRITIQUE_MAX_FINDINGS = AI_CRITIQUE_MAX_FINDINGS; exports.AI_CRITIQUE_MAX_FIELD_LENGTH = AI_CRITIQUE_MAX_FIELD_LENGTH; exports.aiCritiqueRequest = aiCritiqueRequest; exports.checkAiCritique = checkAiCritique; exports.AI_DRAFTS_MAX_COUNT = AI_DRAFTS_MAX_COUNT; exports.AI_DRAFTS_MAX_REPAIRS = AI_DRAFTS_MAX_REPAIRS; exports.aiDraftsRequest = aiDraftsRequest; exports.checkAiDrafts = checkAiDrafts; exports.aiDraftsRepairRequest = aiDraftsRepairRequest; exports.generateDrafts = generateDrafts; exports.interactiveVideoFromDrafts = interactiveVideoFromDrafts; exports.AI_WRITING_MAX_CORRECTIONS = AI_WRITING_MAX_CORRECTIONS; exports.AI_WRITING_MAX_FIELD_LENGTH = AI_WRITING_MAX_FIELD_LENGTH; exports.aiWritingFeedbackRequest = aiWritingFeedbackRequest; exports.checkAiWritingFeedback = checkAiWritingFeedback;
+//# sourceMappingURL=chunk-MXI26H62.cjs.map