@intellectif/lk-core 0.9.0 → 0.10.0

package/dist/{chunk-CVRALNUK.cjs → chunk-7ODQRNR4.cjs}

@@ -179,19 +179,19 @@ var FillInTheBlanksDataSchema = _v4.z.looseObject({
   difficultyLevel: _v4.z.literal([1, 2, 3, 4, 5]).optional()
 }).refine(
   (data) => {
-    const placeholderCounts = /* @__PURE__ */ new Map();
+    const placeholderCounts2 = /* @__PURE__ */ new Map();
     for (const match of data.passage.matchAll(PLACEHOLDER_RE)) {
       const id = match[1];
-      placeholderCounts.set(id, (_nullishCoalesce(placeholderCounts.get(id), () => ( 0))) + 1);
+      placeholderCounts2.set(id, (_nullishCoalesce(placeholderCounts2.get(id), () => ( 0))) + 1);
     }
     const blankIds = data.blanks.map((blank) => blank.id);
     if (new Set(blankIds).size !== blankIds.length) {
       return false;
     }
-    if (placeholderCounts.size !== blankIds.length) {
+    if (placeholderCounts2.size !== blankIds.length) {
       return false;
     }
-    return blankIds.every((id) => placeholderCounts.get(id) === 1);
+    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.",
@@ -199,25 +199,29 @@ var FillInTheBlanksDataSchema = _v4.z.looseObject({
   }
 );
 
-// src/count-words.ts
-function countWords(text) {
-  if (typeof text !== "string") {
-    return 0;
-  }
-  const trimmed = text.trim();
-  if (trimmed === "") {
-    return 0;
-  }
-  return trimmed.split(/\s+/).length;
-}
-
 // src/schemas/multiple-choice.ts
 
+var MultipleChoiceOptionMediaSchema = _v4.z.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: _v4.z.enum(["image", "audio"]),
+  url: MediaUrlSchema,
+  alt: _v4.z.string().min(1).optional(),
+  captionsUrl: MediaUrlSchema.optional()
+}).refine((media) => media.type !== "image" || media.alt !== void 0 && media.alt !== "", {
+  error: "An image option requires a non-empty `alt`.",
+  path: ["alt"]
+}).refine((media) => !("playback" in media), {
+  error: "An option carries no playback policy. maxPlays, seek and rate are enforced only on the media above the question.",
+  path: ["playback"]
+});
 var MultipleChoiceOptionSchema = _v4.z.looseObject({
   id: _v4.z.string().min(1),
   text: _v4.z.string().min(1),
   isCorrect: _v4.z.boolean(),
-  feedback: _v4.z.string().optional()
+  feedback: _v4.z.string().optional(),
+  media: MultipleChoiceOptionMediaSchema.optional()
 });
 var MultipleChoiceDataSchema = _v4.z.looseObject({
   schemaVersion: _v4.z.literal("1.0"),
@@ -250,6 +254,122 @@ var MultipleChoiceDataSchema = _v4.z.looseObject({
   path: ["options"]
 });
 
+// src/count-words.ts
+function countWords(text) {
+  if (typeof text !== "string") {
+    return 0;
+  }
+  const trimmed = text.trim();
+  if (trimmed === "") {
+    return 0;
+  }
+  return trimmed.split(/\s+/).length;
+}
+
+// src/schemas/gap-select.ts
+
+var GapSelectChoiceSchema = _v4.z.looseObject({
+  id: _v4.z.string().min(1),
+  text: _v4.z.string().min(1)
+});
+var GapSelectBankSchema = _v4.z.looseObject({
+  id: _v4.z.string().min(1),
+  choices: _v4.z.array(GapSelectChoiceSchema).min(2)
+});
+var GapSelectGapSchema = _v4.z.looseObject({
+  id: _v4.z.string().min(1),
+  choices: _v4.z.array(GapSelectChoiceSchema).min(2).optional(),
+  bankId: _v4.z.string().min(1).optional(),
+  correctChoiceId: _v4.z.string().min(1),
+  feedback: _v4.z.string().optional()
+});
+function resolveChoices(gap, banks) {
+  if (gap.choices !== void 0) {
+    return gap.bankId === void 0 ? gap.choices : void 0;
+  }
+  if (gap.bankId === void 0) {
+    return void 0;
+  }
+  return _optionalChain([banks, 'access', _10 => _10.find, 'call', _11 => _11((bank) => bank.id === gap.bankId), 'optionalAccess', _12 => _12.choices]);
+}
+function placeholderCounts(passage) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const match of passage.matchAll(PLACEHOLDER_RE)) {
+    const id = match[1];
+    counts.set(id, (_nullishCoalesce(counts.get(id), () => ( 0))) + 1);
+  }
+  return counts;
+}
+var GapSelectDataSchema = _v4.z.looseObject({
+  schemaVersion: _v4.z.literal("1.0"),
+  type: _v4.z.literal("gap-select"),
+  id: _v4.z.string().min(1),
+  title: _v4.z.string().min(1),
+  passage: _v4.z.string().min(1),
+  passageHtml: _v4.z.string().optional(),
+  gaps: _v4.z.array(GapSelectGapSchema).min(1),
+  banks: _v4.z.array(GapSelectBankSchema).optional(),
+  scoringStrategy: _v4.z.enum(["all-or-nothing", "partial"]),
+  presentation: _v4.z.literal("dropdown").optional(),
+  shuffleChoices: _v4.z.boolean().optional(),
+  media: MediaSchema.optional(),
+  feedback: FeedbackSchema.optional(),
+  passThreshold: _v4.z.number().min(0).max(1).optional(),
+  locale: _v4.z.string().optional(),
+  learningObjectives: _v4.z.array(_v4.z.string()).optional(),
+  difficultyLevel: _v4.z.literal([1, 2, 3, 4, 5]).optional()
+}).refine(
+  (data) => {
+    const ids = (_nullishCoalesce(data.banks, () => ( []))).map((bank) => bank.id);
+    return new Set(ids).size === ids.length;
+  },
+  { error: "Word bank ids must be unique.", path: ["banks"] }
+).refine(
+  (data) => {
+    const ids = data.gaps.map((gap) => gap.id);
+    return new Set(ids).size === ids.length;
+  },
+  { error: "Gap ids must be unique.", path: ["gaps"] }
+).refine(
+  (data) => {
+    const counts = placeholderCounts(data.passage);
+    const ids = data.gaps.map((gap) => gap.id);
+    return counts.size === new Set(ids).size && ids.every((id) => counts.get(id) === 1) && [...counts.values()].every((count) => count === 1);
+  },
+  {
+    error: "Every gap must appear exactly once in the passage as {{gap_id}}, and every {{gap_id}} must have a gap.",
+    path: ["passage"]
+  }
+).refine(
+  (data) => data.gaps.every((gap) => gap.choices === void 0 !== (gap.bankId === void 0)),
+  {
+    error: "Each gap needs exactly one choice source: its own `choices`, or a `bankId`.",
+    path: ["gaps"]
+  }
+).refine(
+  (data) => {
+    const bankIds = new Set((_nullishCoalesce(data.banks, () => ( []))).map((bank) => bank.id));
+    return data.gaps.every((gap) => gap.bankId === void 0 || bankIds.has(gap.bankId));
+  },
+  { error: "A gap references a `bankId` that no word bank defines.", path: ["gaps"] }
+).refine(
+  (data) => {
+    const banks = _nullishCoalesce(data.banks, () => ( []));
+    return data.gaps.every((gap) => {
+      const choices = resolveChoices(gap, banks);
+      if (choices === void 0) {
+        return true;
+      }
+      const ids = choices.map((choice) => choice.id);
+      return new Set(ids).size === ids.length && ids.includes(gap.correctChoiceId);
+    });
+  },
+  {
+    error: "Each gap needs unique choice ids and a `correctChoiceId` that is one of the choices it offers.",
+    path: ["gaps"]
+  }
+);
+
 // src/schemas/written-response.ts
 
 var WrittenResponseRubricCriterionSchema = _v4.z.looseObject({
@@ -308,9 +428,16 @@ var redactedBase = {
   learningObjectives: _v4.z.array(_v4.z.string()).optional(),
   difficultyLevel: _v4.z.literal([1, 2, 3, 4, 5]).optional()
 };
+var RedactedMultipleChoiceOptionMediaSchema = _v4.z.strictObject({
+  type: _v4.z.enum(["image", "audio"]),
+  url: _v4.z.string().min(1),
+  alt: _v4.z.string().min(1).optional(),
+  captionsUrl: _v4.z.string().min(1).optional()
+});
 var RedactedMultipleChoiceOptionSchema = _v4.z.strictObject({
   id: _v4.z.string().min(1),
-  text: _v4.z.string().min(1)
+  text: _v4.z.string().min(1),
+  media: RedactedMultipleChoiceOptionMediaSchema.optional()
 });
 var RedactedMultipleChoiceDataSchema = _v4.z.strictObject({
   ...redactedBase,
@@ -332,6 +459,29 @@ var RedactedFillInTheBlanksDataSchema = _v4.z.strictObject({
   passageHtml: _v4.z.string().optional(),
   blanks: _v4.z.array(RedactedBlankConfigSchema).min(1)
 });
+var RedactedGapSelectChoiceSchema = _v4.z.strictObject({
+  id: _v4.z.string().min(1),
+  text: _v4.z.string().min(1)
+});
+var RedactedGapSelectBankSchema = _v4.z.strictObject({
+  id: _v4.z.string().min(1),
+  choices: _v4.z.array(RedactedGapSelectChoiceSchema).min(2)
+});
+var RedactedGapSelectGapSchema = _v4.z.strictObject({
+  id: _v4.z.string().min(1),
+  choices: _v4.z.array(RedactedGapSelectChoiceSchema).min(2).optional(),
+  bankId: _v4.z.string().min(1).optional()
+});
+var RedactedGapSelectDataSchema = _v4.z.strictObject({
+  ...redactedBase,
+  type: _v4.z.literal("gap-select"),
+  passage: _v4.z.string().min(1),
+  passageHtml: _v4.z.string().optional(),
+  gaps: _v4.z.array(RedactedGapSelectGapSchema).min(1),
+  banks: _v4.z.array(RedactedGapSelectBankSchema).optional(),
+  presentation: _v4.z.literal("dropdown").optional(),
+  shuffleChoices: _v4.z.boolean().optional()
+});
 var RedactedWrittenResponseDataSchema = _v4.z.strictObject({
   ...redactedBase,
   type: _v4.z.literal("written-response"),
@@ -484,6 +634,7 @@ var DRAFT_ISSUE_SEVERITY = {
   mc_option_id_duplicate: "invalid",
   mc_option_text_required: "incomplete",
   mc_option_correctness_required: "incomplete",
+  mc_option_media_kind: "invalid",
   mc_correct_option_required: "incomplete",
   mc_single_mode_one_correct: "invalid",
   // fill-in-the-blanks
@@ -500,6 +651,27 @@ var DRAFT_ISSUE_SEVERITY = {
   fib_placeholder_missing: "incomplete",
   fib_placeholder_duplicate: "invalid",
   fib_blanks_mismatch: "invalid",
+  // gap-select
+  gs_passage_required: "incomplete",
+  gs_gaps_required: "incomplete",
+  gs_gap_id_required: "invalid",
+  gs_gap_id_duplicate: "invalid",
+  gs_gap_missing: "incomplete",
+  gs_placeholder_missing: "incomplete",
+  gs_placeholder_duplicate: "invalid",
+  gs_gaps_mismatch: "invalid",
+  gs_presentation_invalid: "invalid",
+  gs_bank_id_required: "invalid",
+  gs_bank_id_duplicate: "invalid",
+  gs_bank_unknown: "invalid",
+  gs_choice_source_required: "incomplete",
+  gs_choice_source_conflict: "invalid",
+  gs_choices_too_few: "incomplete",
+  gs_choice_id_required: "invalid",
+  gs_choice_id_duplicate: "invalid",
+  gs_choice_text_required: "incomplete",
+  gs_correct_choice_required: "incomplete",
+  gs_correct_choice_unknown: "invalid",
   // written-response
   wr_prompt_required: "incomplete",
   wr_min_words_required: "incomplete",
@@ -633,51 +805,42 @@ function checkSharedOptional(draft) {
 }
 var URL_POLICY = 'Use an https:, http:, data: or blob: address, or a path on the same site that starts with a single "/".';
 var EMBED_URL = "An embed needs the provider's full http(s) embed address, such as https://www.youtube.com/embed/VIDEO_ID.";
-function checkMedia(media) {
+function checkMedia(media, prefix = ["media"], schema = MediaSchema) {
   const issues = [];
-  const parsed = MediaSchema.safeParse(media, { reportInput: true });
+  const at = (...rest) => [...prefix, ...rest];
+  const parsed = schema.safeParse(media, { reportInput: true });
   const schemaIssues = parsed.success ? [] : parsed.error.issues.filter((found) => !refusesEmpty(media, found));
   const refusal = (field) => schemaIssues.find((found) => found.path[0] === field);
   const typeUnset = isUnwritten(media.type);
   if (typeUnset) {
-    issues.push(
-      issue("media_type_required", ["media", "type"], "Choose what kind of media this is.")
-    );
+    issues.push(issue("media_type_required", at("type"), "Choose what kind of media this is."));
   }
   if (isUnwritten(media.url)) {
-    issues.push(
-      issue("media_url_required", ["media", "url"], "Add the address of the media file.")
-    );
+    issues.push(issue("media_url_required", at("url"), "Add the address of the media file."));
   } else {
     const refused = refusal("url");
     if (refused !== void 0) {
       issues.push(
-        issue(
-          "media_url_invalid",
-          ["media", "url"],
-          refused.code === "custom" ? EMBED_URL : URL_POLICY
-        )
+        issue("media_url_invalid", at("url"), refused.code === "custom" ? EMBED_URL : URL_POLICY)
       );
     }
   }
   const needsAlt = media.type === "image" || media.type === "embed";
   const alt = media.alt;
   if (needsAlt && isUnwritten(alt) || typeof alt === "string" && alt.trim() === "") {
-    issues.push(
-      issue("media_alt_required", ["media", "alt"], "Add a text description of the media.")
-    );
+    issues.push(issue("media_alt_required", at("alt"), "Add a text description of the media."));
   }
   const captions = media.captionsUrl;
   if (typeof captions === "string" && captions.trim() === "") {
     issues.push(
       issue(
         "media_url_required",
-        ["media", "captionsUrl"],
+        at("captionsUrl"),
         "Add the address of the captions file, or remove the captions."
       )
     );
   } else if (refusal("captionsUrl") !== void 0) {
-    issues.push(issue("media_url_invalid", ["media", "captionsUrl"], URL_POLICY));
+    issues.push(issue("media_url_invalid", at("captionsUrl"), URL_POLICY));
   }
   for (const schemaIssue of schemaIssues) {
     const field = schemaIssue.path[0];
@@ -687,7 +850,7 @@ function checkMedia(media) {
     issues.push(
       issue(
         field === "playback" ? "media_playback_invalid" : "media_invalid",
-        ["media", ...schemaIssue.path.map(String)],
+        at(...schemaIssue.path.map(String)),
         schemaIssue.message
       )
     );
@@ -888,6 +1051,301 @@ function pairsOneToOne(placeholders, blanks) {
   return blankIds.every((id) => typeof id === "string" && placeholders.get(id) === 1);
 }
 
+// src/authoring/gap-select.ts
+var MIN_CHOICES = 2;
+var gapSelectAuthoring = {
+  createDraft: ({ newId }) => ({
+    schemaVersion: "1.0",
+    type: "gap-select",
+    id: newId(),
+    title: "",
+    passage: "",
+    gaps: [],
+    scoringStrategy: "all-or-nothing"
+  }),
+  checkDraft: checkGapSelectDraft
+};
+function checkGapSelectDraft(draft) {
+  const issues = checkIdentity(draft, "gap-select");
+  const passage = draft.passage;
+  if (isUnwritten(passage)) {
+    issues.push(issue("gs_passage_required", ["passage"], "Write the passage."));
+  }
+  issues.push(...checkScoringStrategy(draft));
+  if (!isUnset(draft.presentation) && draft.presentation !== "dropdown") {
+    issues.push(
+      issue(
+        "gs_presentation_invalid",
+        ["presentation"],
+        'The only presentation is "dropdown". Leave it out unless you mean to set it.'
+      )
+    );
+  }
+  const banks = isUnset(draft.banks) ? [] : draft.banks;
+  const bankIds = /* @__PURE__ */ new Set();
+  if (Array.isArray(banks)) {
+    issues.push(...checkBanks(banks, bankIds));
+  }
+  const gaps = isUnset(draft.gaps) ? [] : draft.gaps;
+  const gapIds = [];
+  if (Array.isArray(gaps)) {
+    if (gaps.length === 0) {
+      issues.push(
+        issue(
+          "gs_gaps_required",
+          ["gaps"],
+          "Add at least one gap, and mark where it goes in the passage with {{id}}."
+        )
+      );
+    }
+    issues.push(...checkGaps(gaps, banks, bankIds, gapIds));
+    if (typeof passage === "string" && passage.trim() !== "") {
+      issues.push(...checkPairing2(passage, gaps, gapIds));
+    }
+  }
+  issues.push(...checkSharedOptional(draft));
+  return issues;
+}
+function checkBanks(banks, bankIds) {
+  const issues = [];
+  const repeated = /* @__PURE__ */ new Set();
+  for (const [index, bank] of banks.entries()) {
+    if (!isRecord(bank)) {
+      continue;
+    }
+    if (isMissingId(bank.id)) {
+      issues.push(
+        issue("gs_bank_id_required", ["banks", index, "id"], `Word bank ${index + 1} has no id.`)
+      );
+    } else if (typeof bank.id === "string") {
+      if (bankIds.has(bank.id)) {
+        repeated.add(bank.id);
+      }
+      bankIds.add(bank.id);
+    }
+    const name = typeof bank.id === "string" && bank.id !== "" ? `"${bank.id}"` : index + 1;
+    issues.push(...checkChoiceList(bank.choices, ["banks", index, "choices"], `word bank ${name}`));
+  }
+  for (const id of repeated) {
+    issues.push(
+      issue("gs_bank_id_duplicate", ["banks"], `More than one word bank has the id "${id}".`)
+    );
+  }
+  return issues;
+}
+function checkGaps(gaps, banks, bankIds, gapIds) {
+  const issues = [];
+  const atGaps = [];
+  const repeated = /* @__PURE__ */ new Set();
+  const seen = /* @__PURE__ */ new Set();
+  for (const [index, gap] of gaps.entries()) {
+    if (!isRecord(gap)) {
+      continue;
+    }
+    const ordinal = index + 1;
+    const name = typeof gap.id === "string" && gap.id !== "" ? `"${gap.id}"` : ordinal;
+    if (isMissingId(gap.id)) {
+      issues.push(issue("gs_gap_id_required", ["gaps", index, "id"], `Gap ${ordinal} has no id.`));
+    } else if (typeof gap.id === "string") {
+      if (seen.has(gap.id)) {
+        repeated.add(gap.id);
+      }
+      seen.add(gap.id);
+      gapIds.push(gap.id);
+    }
+    const hasOwn = !isUnset(gap.choices);
+    const hasBank = !isUnwritten(gap.bankId);
+    const bankBlank = typeof gap.bankId === "string" && gap.bankId.trim() === "";
+    if (bankBlank) {
+      issues.push(
+        issue(
+          "gs_choice_source_required",
+          ["gaps", index, "bankId"],
+          `Choose a word bank for gap ${name}, or remove the empty field.`
+        )
+      );
+    } else if (hasOwn && hasBank) {
+      atGaps.push(
+        issue(
+          "gs_choice_source_conflict",
+          ["gaps"],
+          `Gap ${name} has both its own choices and a word bank. Use one or the other.`
+        )
+      );
+    } else if (!hasOwn && !hasBank) {
+      atGaps.push(
+        issue(
+          "gs_choice_source_required",
+          ["gaps"],
+          `Give gap ${name} a list of choices, or point it at a word bank.`
+        )
+      );
+    }
+    if (hasBank && typeof gap.bankId === "string" && !bankIds.has(gap.bankId)) {
+      atGaps.push(
+        issue(
+          "gs_bank_unknown",
+          ["gaps"],
+          `Gap ${name} uses the word bank "${gap.bankId}", which does not exist.`
+        )
+      );
+    }
+    if (hasOwn) {
+      issues.push(...checkChoiceList(gap.choices, ["gaps", index, "choices"], `gap ${name}`));
+    }
+    issues.push(...checkAnswerKey(gap, index, name, banks, bankIds));
+  }
+  for (const id of repeated) {
+    atGaps.push(issue("gs_gap_id_duplicate", ["gaps"], `More than one gap has the id "${id}".`));
+  }
+  return [...issues, ...atGaps];
+}
+function checkAnswerKey(gap, index, name, banks, bankIds) {
+  const key = gap.correctChoiceId;
+  if (isUnwritten(key)) {
+    return [
+      issue(
+        "gs_correct_choice_required",
+        ["gaps", index, "correctChoiceId"],
+        `Mark the correct choice for gap ${name}.`
+      )
+    ];
+  }
+  if (typeof key !== "string") {
+    return [];
+  }
+  const choices = resolveChoices2(gap, banks, bankIds);
+  if (choices === void 0) {
+    return [];
+  }
+  const offered = choices.some((choice) => isRecord(choice) && choice.id === key);
+  return offered ? [] : [
+    issue(
+      "gs_correct_choice_unknown",
+      ["gaps"],
+      `Gap ${name} is marked correct on "${key}", which is not one of its choices.`
+    )
+  ];
+}
+function resolveChoices2(gap, banks, bankIds) {
+  const hasOwn = !isUnset(gap.choices);
+  const hasBank = !isUnwritten(gap.bankId);
+  if (hasOwn === hasBank) {
+    return void 0;
+  }
+  if (hasOwn) {
+    return Array.isArray(gap.choices) ? gap.choices : void 0;
+  }
+  if (typeof gap.bankId !== "string" || !bankIds.has(gap.bankId) || !Array.isArray(banks)) {
+    return void 0;
+  }
+  const bank = banks.find((entry) => isRecord(entry) && entry.id === gap.bankId);
+  return isRecord(bank) && Array.isArray(bank.choices) ? bank.choices : void 0;
+}
+function checkChoiceList(choices, path, owner) {
+  const issues = [];
+  const list = isUnset(choices) ? [] : choices;
+  if (!Array.isArray(list)) {
+    return issues;
+  }
+  if (list.length < MIN_CHOICES) {
+    issues.push(
+      issue(
+        "gs_choices_too_few",
+        path,
+        `Give ${owner} at least ${MIN_CHOICES} choices to pick from.`
+      )
+    );
+  }
+  const seen = /* @__PURE__ */ new Set();
+  const repeated = /* @__PURE__ */ new Set();
+  for (const [index, choice] of list.entries()) {
+    if (!isRecord(choice)) {
+      continue;
+    }
+    if (isMissingId(choice.id)) {
+      issues.push(
+        issue("gs_choice_id_required", [...path, index, "id"], `Choice ${index + 1} has no id.`)
+      );
+    } else if (typeof choice.id === "string") {
+      if (seen.has(choice.id)) {
+        repeated.add(choice.id);
+      }
+      seen.add(choice.id);
+    }
+    if (isUnwritten(choice.text)) {
+      issues.push(
+        issue(
+          "gs_choice_text_required",
+          [...path, index, "text"],
+          `Write the text of choice ${index + 1}.`
+        )
+      );
+    }
+  }
+  for (const id of repeated) {
+    issues.push(issue("gs_choice_id_duplicate", path, `More than one choice has the id "${id}".`));
+  }
+  return issues;
+}
+function checkPairing2(passage, gaps, gapIds) {
+  const issues = [];
+  const placeholders = /* @__PURE__ */ new Map();
+  for (const match of passage.matchAll(PLACEHOLDER_RE)) {
+    const id = match[1];
+    placeholders.set(id, (_nullishCoalesce(placeholders.get(id), () => ( 0))) + 1);
+  }
+  const ids = new Set(gapIds);
+  for (const [id, count] of placeholders) {
+    if (count > 1) {
+      issues.push(
+        issue(
+          "gs_placeholder_duplicate",
+          ["passage"],
+          `{{${id}}} appears more than once in the passage. Each gap goes in one place.`
+        )
+      );
+    }
+    if (!ids.has(id)) {
+      issues.push(
+        issue(
+          "gs_gap_missing",
+          ["passage"],
+          `The passage has {{${id}}}, but there is no gap with that id.`
+        )
+      );
+    }
+  }
+  for (const id of ids) {
+    if (!placeholders.has(id)) {
+      issues.push(
+        issue(
+          "gs_placeholder_missing",
+          ["passage"],
+          `Gap "${id}" is not in the passage. Put {{${id}}} where it goes.`
+        )
+      );
+    }
+  }
+  if (issues.length === 0 && !pairsOneToOne2(placeholders, gaps)) {
+    issues.push(
+      issue(
+        "gs_gaps_mismatch",
+        ["passage"],
+        "The gaps and the {{id}} placeholders in the passage do not pair up one to one."
+      )
+    );
+  }
+  return issues;
+}
+function pairsOneToOne2(placeholders, gaps) {
+  const ids = gaps.filter(isRecord).map((gap) => gap.id);
+  if (new Set(ids).size !== ids.length || placeholders.size !== ids.length) {
+    return false;
+  }
+  return ids.every((id) => typeof id === "string" && placeholders.get(id) === 1);
+}
+
 // src/authoring/multiple-choice.ts
 var MIN_OPTIONS = 2;
 var MAX_OPTIONS = 26;
@@ -967,6 +1425,9 @@ function checkMultipleChoiceDraft(draft) {
       if (option.isCorrect === true) {
         correct += 1;
       }
+      if (isRecord(option.media)) {
+        issues.push(...checkOptionMedia(option.media, index, ordinal));
+      }
     }
     for (const id of repeated) {
       issues.push(
@@ -994,6 +1455,20 @@ function checkMultipleChoiceDraft(draft) {
   issues.push(...checkSharedOptional(draft));
   return issues;
 }
+function checkOptionMedia(media, index, ordinal) {
+  const path = ["options", index, "media"];
+  const kind = media.type;
+  if (kind === "video" || kind === "embed") {
+    return [
+      issue(
+        "mc_option_media_kind",
+        [...path, "type"],
+        `Option ${ordinal} carries ${kind === "embed" ? "an embedded player" : "a video"}, which cannot be an option: its controls swallow the click that selects the answer. Use a picture or a recording.`
+      )
+    ];
+  }
+  return checkMedia(media, path, MultipleChoiceOptionMediaSchema);
+}
 
 // src/authoring/written-response.ts
 var writtenResponseAuthoring = {
@@ -1181,6 +1656,38 @@ function scoreFillInTheBlanks(data, response) {
   return { score: scoreValue, maxScore: 1, feedback: null, details };
 }
 
+// src/scoring/activity-scorers/gap-select.ts
+function choicesFor(data, gap) {
+  if (gap.choices !== void 0) {
+    return gap.choices;
+  }
+  return _nullishCoalesce(_optionalChain([data, 'access', _13 => _13.banks, 'optionalAccess', _14 => _14.find, 'call', _15 => _15((bank) => bank.id === gap.bankId), 'optionalAccess', _16 => _16.choices]), () => ( []));
+}
+function scoreGapSelect(data, response) {
+  const details = [];
+  const perGapCorrect = [];
+  for (const gap of data.gaps) {
+    const raw = response.selections[gap.id];
+    const selected = typeof raw === "string" ? raw : "";
+    const choices = choicesFor(data, gap);
+    const offered = choices.some((choice) => choice.id === selected);
+    const answered = selected !== "" && offered;
+    const correct = answered && selected === gap.correctChoiceId;
+    perGapCorrect.push(correct);
+    details.push({
+      itemId: gap.id,
+      correct,
+      outcome: correct ? "correct" : answered ? "incorrect" : "incorrect-omission",
+      learnerResponse: [selected],
+      correctResponse: [gap.correctChoiceId],
+      weight: 1
+    });
+  }
+  const correctGaps = perGapCorrect.filter(Boolean).length;
+  const scoreValue = data.scoringStrategy === "all-or-nothing" ? allOrNothingStrategy(perGapCorrect) : partialBlankStrategy(correctGaps, data.gaps.length);
+  return { score: scoreValue, maxScore: 1, feedback: null, details };
+}
+
 // src/scoring/activity-scorers/multiple-choice.ts
 function scoreMultipleChoice(data, response) {
   const optionById = new Map(data.options.map((option) => [option.id, option]));
@@ -1190,7 +1697,7 @@ function scoreMultipleChoice(data, response) {
   let scoreValue;
   if (data.scoringStrategy === "all-or-nothing") {
     if (data.mode === "single") {
-      scoreValue = response.selectedOptionIds.length === 1 && _optionalChain([optionById, 'access', _10 => _10.get, 'call', _11 => _11(response.selectedOptionIds[0]), 'optionalAccess', _12 => _12.isCorrect]) === true ? 1 : 0;
+      scoreValue = response.selectedOptionIds.length === 1 && _optionalChain([optionById, 'access', _17 => _17.get, 'call', _18 => _18(response.selectedOptionIds[0]), 'optionalAccess', _19 => _19.isCorrect]) === true ? 1 : 0;
     } else {
       const correctIds = data.options.filter((o) => o.isCorrect).map((o) => o.id);
       const allCorrectSelected = correctIds.every((id) => selected.has(id));
@@ -1201,7 +1708,7 @@ function scoreMultipleChoice(data, response) {
     let incorrectSelected = 0;
     for (const id of selected) {
       const option = optionById.get(id);
-      if (_optionalChain([option, 'optionalAccess', _13 => _13.isCorrect])) {
+      if (_optionalChain([option, 'optionalAccess', _20 => _20.isCorrect])) {
         correctSelected += 1;
       } else {
         incorrectSelected += 1;
@@ -1280,6 +1787,38 @@ var MULTIPLE_CHOICE_FIELD_POLICY = {
     id: "public",
     text: "public",
     isCorrect: "answer-key",
+    feedback: "answer-key",
+    // Public, and classified key by key rather than as one leaf — the lesson
+    // `media`, `rubric` and `feedback` each taught: a scalar classification
+    // assigns the author's object by reference without recursing, so an
+    // unclassified key parked inside it survives redact() AND assertRedacted().
+    // An option's picture or recording IS the thing the learner picks, so
+    // stripping it would ship a row of blank options.
+    media: {
+      type: "public",
+      url: "public",
+      alt: "public",
+      captionsUrl: "public"
+    }
+  }
+};
+var GAP_SELECT_FIELD_POLICY = {
+  ...SHARED_PUBLIC_FIELDS,
+  passage: "public",
+  passageHtml: "public",
+  presentation: "public",
+  shuffleChoices: "public",
+  scoringStrategy: "answer-key",
+  feedback: FEEDBACK_FIELD_POLICY,
+  banks: {
+    id: "public",
+    choices: { id: "public", text: "public" }
+  },
+  gaps: {
+    id: "public",
+    bankId: "public",
+    choices: { id: "public", text: "public" },
+    correctChoiceId: "answer-key",
     feedback: "answer-key"
   }
 };
@@ -1331,7 +1870,7 @@ var multipleChoiceType = defineActivityType({
   // exact optionals. Structurally identical at runtime — cast is type-level only.
   schema: MultipleChoiceDataSchema,
   scoring: { kind: "sync", score: scoreMultipleChoice },
-  isAnswered: (response) => (_nullishCoalesce(_optionalChain([response, 'optionalAccess', _14 => _14.selectedOptionIds, 'access', _15 => _15.length]), () => ( 0))) > 0,
+  isAnswered: (response) => (_nullishCoalesce(_optionalChain([response, 'optionalAccess', _21 => _21.selectedOptionIds, 'access', _22 => _22.length]), () => ( 0))) > 0,
   fieldPolicy: MULTIPLE_CHOICE_FIELD_POLICY,
   redactedSchema: RedactedMultipleChoiceDataSchema,
   interop: {
@@ -1348,7 +1887,7 @@ var fillInTheBlanksType = defineActivityType({
   type: "fill-in-the-blanks",
   schema: FillInTheBlanksDataSchema,
   scoring: { kind: "sync", score: scoreFillInTheBlanks },
-  isAnswered: (response) => Object.values(_nullishCoalesce(_optionalChain([response, 'optionalAccess', _16 => _16.answers]), () => ( {}))).some((answer) => answer.trim().length > 0),
+  isAnswered: (response) => Object.values(_nullishCoalesce(_optionalChain([response, 'optionalAccess', _23 => _23.answers]), () => ( {}))).some((answer) => answer.trim().length > 0),
   fieldPolicy: FILL_IN_THE_BLANKS_FIELD_POLICY,
   redactedSchema: RedactedFillInTheBlanksDataSchema,
   interop: {
@@ -1371,14 +1910,14 @@ var writtenResponseType = defineActivityType({
     kind: "deferred",
     reason: "requires_async_grading",
     partial: (data, response) => {
-      const wordCount = countWords(_nullishCoalesce(_optionalChain([response, 'optionalAccess', _17 => _17.text]), () => ( "")));
+      const wordCount = countWords(_nullishCoalesce(_optionalChain([response, 'optionalAccess', _24 => _24.text]), () => ( "")));
       return {
         withinWordBounds: response !== void 0 && wordCount >= data.minWords && wordCount <= data.maxWords,
         wordCount
       };
     }
   },
-  isAnswered: (response) => (_nullishCoalesce(_optionalChain([response, 'optionalAccess', _18 => _18.text, 'access', _19 => _19.trim, 'call', _20 => _20(), 'access', _21 => _21.length]), () => ( 0))) > 0,
+  isAnswered: (response) => (_nullishCoalesce(_optionalChain([response, 'optionalAccess', _25 => _25.text, 'access', _26 => _26.trim, 'call', _27 => _27(), 'access', _28 => _28.length]), () => ( 0))) > 0,
   fieldPolicy: WRITTEN_RESPONSE_FIELD_POLICY,
   redactedSchema: RedactedWrittenResponseDataSchema,
   interop: {
@@ -1389,9 +1928,43 @@ var writtenResponseType = defineActivityType({
   interactions: ["text-changed", "submitted"],
   authoring: writtenResponseAuthoring
 });
+var gapSelectType = defineActivityType({
+  type: "gap-select",
+  schema: GapSelectDataSchema,
+  scoring: { kind: "sync", score: scoreGapSelect },
+  isAnswered: (response) => Object.values(_nullishCoalesce(_optionalChain([response, 'optionalAccess', _29 => _29.selections]), () => ( {}))).some((choiceId) => choiceId !== ""),
+  fieldPolicy: GAP_SELECT_FIELD_POLICY,
+  redactedSchema: RedactedGapSelectDataSchema,
+  interop: {
+    xapiActivityTypeIri: "http://adlnet.gov/expapi/activities/cmi.interaction",
+    // `matching`, not `choice` or `fill-in`. The learner pairs a set of sources
+    // (the gaps) with a set of targets (the choices), which is exactly what the
+    // xAPI matching interaction describes, and it is the only built-in type
+    // whose pattern can name WHICH gap took which answer. `fill-in` — what the
+    // Fill-in-the-Blanks descriptor uses — would flatten the gaps into an
+    // ordered list of strings and lose that.
+    xapiInteractionType: "matching",
+    correctResponsesPattern: (data) => [
+      data.gaps.map((gap) => `${gap.id}[.]${gap.correctChoiceId}`).join("[,]")
+    ]
+  },
+  interactions: ["gap-selected", "submitted"],
+  authoring: gapSelectAuthoring
+});
 registerActivityType(multipleChoiceType);
 registerActivityType(fillInTheBlanksType);
 registerActivityType(writtenResponseType);
+registerActivityType(gapSelectType);
+
+
+
+
+
+
+
+
+
+
 
 
 
@@ -1432,5 +2005,5 @@ registerActivityType(writtenResponseType);
 
 
 
-exports.ActivitySchemaError = ActivitySchemaError; exports.UnknownActivityTypeError = UnknownActivityTypeError; exports.RedactedScoringError = RedactedScoringError; exports.DeferredScoringError = DeferredScoringError; exports.FeedbackSchema = FeedbackSchema; exports.MediaUrlSchema = MediaUrlSchema; exports.NativeControlHintSchema = NativeControlHintSchema; exports.MediaPlaybackSchema = MediaPlaybackSchema; exports.MediaSchema = MediaSchema; exports.RedactedMediaSchema = RedactedMediaSchema; exports.TextMatchPolicySchema = TextMatchPolicySchema; exports.BlankConfigSchema = BlankConfigSchema; exports.FillInTheBlanksDataSchema = FillInTheBlanksDataSchema; exports.DRAFT_ISSUE_SEVERITY = DRAFT_ISSUE_SEVERITY; exports.issue = issue; exports.isRecord = isRecord; exports.refusesEmpty = refusesEmpty; exports.countWords = countWords; exports.MultipleChoiceOptionSchema = MultipleChoiceOptionSchema; exports.MultipleChoiceDataSchema = MultipleChoiceDataSchema; exports.WrittenResponseRubricCriterionSchema = WrittenResponseRubricCriterionSchema; exports.WrittenResponseRubricSchema = WrittenResponseRubricSchema; exports.WrittenResponseDataSchema = WrittenResponseDataSchema; exports.RedactedMultipleChoiceOptionSchema = RedactedMultipleChoiceOptionSchema; exports.RedactedMultipleChoiceDataSchema = RedactedMultipleChoiceDataSchema; exports.RedactedBlankConfigSchema = RedactedBlankConfigSchema; exports.RedactedFillInTheBlanksDataSchema = RedactedFillInTheBlanksDataSchema; exports.RedactedWrittenResponseDataSchema = RedactedWrittenResponseDataSchema; exports.levenshteinDistance = levenshteinDistance; exports.matchText = matchText; exports.defineActivityType = defineActivityType; exports.registerActivityType = registerActivityType; exports.getActivityTypeDescriptor = getActivityTypeDescriptor; exports.registeredActivityTypes = registeredActivityTypes; exports.MEDIA_FIELD_POLICY = MEDIA_FIELD_POLICY; exports.multipleChoiceType = multipleChoiceType; exports.fillInTheBlanksType = fillInTheBlanksType; exports.writtenResponseType = writtenResponseType;
-//# sourceMappingURL=chunk-CVRALNUK.cjs.map
+exports.ActivitySchemaError = ActivitySchemaError; exports.UnknownActivityTypeError = UnknownActivityTypeError; exports.RedactedScoringError = RedactedScoringError; exports.DeferredScoringError = DeferredScoringError; exports.FeedbackSchema = FeedbackSchema; exports.MediaUrlSchema = MediaUrlSchema; exports.NativeControlHintSchema = NativeControlHintSchema; exports.MediaPlaybackSchema = MediaPlaybackSchema; exports.MediaSchema = MediaSchema; exports.RedactedMediaSchema = RedactedMediaSchema; exports.TextMatchPolicySchema = TextMatchPolicySchema; exports.BlankConfigSchema = BlankConfigSchema; exports.FillInTheBlanksDataSchema = FillInTheBlanksDataSchema; exports.DRAFT_ISSUE_SEVERITY = DRAFT_ISSUE_SEVERITY; exports.issue = issue; exports.isRecord = isRecord; exports.refusesEmpty = refusesEmpty; exports.MultipleChoiceOptionMediaSchema = MultipleChoiceOptionMediaSchema; exports.MultipleChoiceOptionSchema = MultipleChoiceOptionSchema; exports.MultipleChoiceDataSchema = MultipleChoiceDataSchema; exports.countWords = countWords; exports.GapSelectChoiceSchema = GapSelectChoiceSchema; exports.GapSelectBankSchema = GapSelectBankSchema; exports.GapSelectGapSchema = GapSelectGapSchema; exports.GapSelectDataSchema = GapSelectDataSchema; exports.WrittenResponseRubricCriterionSchema = WrittenResponseRubricCriterionSchema; exports.WrittenResponseRubricSchema = WrittenResponseRubricSchema; exports.WrittenResponseDataSchema = WrittenResponseDataSchema; exports.RedactedMultipleChoiceOptionMediaSchema = RedactedMultipleChoiceOptionMediaSchema; exports.RedactedMultipleChoiceOptionSchema = RedactedMultipleChoiceOptionSchema; exports.RedactedMultipleChoiceDataSchema = RedactedMultipleChoiceDataSchema; exports.RedactedBlankConfigSchema = RedactedBlankConfigSchema; exports.RedactedFillInTheBlanksDataSchema = RedactedFillInTheBlanksDataSchema; exports.RedactedGapSelectChoiceSchema = RedactedGapSelectChoiceSchema; exports.RedactedGapSelectBankSchema = RedactedGapSelectBankSchema; exports.RedactedGapSelectGapSchema = RedactedGapSelectGapSchema; exports.RedactedGapSelectDataSchema = RedactedGapSelectDataSchema; exports.RedactedWrittenResponseDataSchema = RedactedWrittenResponseDataSchema; exports.levenshteinDistance = levenshteinDistance; exports.matchText = matchText; exports.defineActivityType = defineActivityType; exports.registerActivityType = registerActivityType; exports.getActivityTypeDescriptor = getActivityTypeDescriptor; exports.registeredActivityTypes = registeredActivityTypes; exports.MEDIA_FIELD_POLICY = MEDIA_FIELD_POLICY; exports.multipleChoiceType = multipleChoiceType; exports.fillInTheBlanksType = fillInTheBlanksType; exports.writtenResponseType = writtenResponseType;
+//# sourceMappingURL=chunk-7ODQRNR4.cjs.map