@intellectif/lk-core 0.9.0 → 0.10.1

package/dist/{chunk-AHEUYOT3.js → chunk-FIS5KBCE.js}

@@ -179,19 +179,19 @@ var FillInTheBlanksDataSchema = z3.looseObject({
   difficultyLevel: z3.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, (placeholderCounts.get(id) ?? 0) + 1);
+      placeholderCounts2.set(id, (placeholderCounts2.get(id) ?? 0) + 1);
     }
     const blankIds = data.blanks.map((blank) => blank.id);
     if (new Set(blankIds).size !== blankIds.length) {
       return false;
     }
-    if (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 = z3.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
 import { z as z4 } from "zod/v4";
+var MultipleChoiceOptionMediaSchema = z4.looseObject({
+  // No `embed`: an iframe swallows the click that selects the option, so the
+  // learner could not choose it. No `video`: a native control bar inside the
+  // option's label eats the same click.
+  type: z4.enum(["image", "audio"]),
+  url: MediaUrlSchema,
+  alt: z4.string().min(1).optional(),
+  captionsUrl: MediaUrlSchema.optional()
+}).refine((media) => media.type !== "image" || media.alt !== void 0 && media.alt !== "", {
+  error: "An image option requires a non-empty `alt`.",
+  path: ["alt"]
+}).refine((media) => !("playback" in media), {
+  error: "An option carries no playback policy. maxPlays, seek and rate are enforced only on the media above the question.",
+  path: ["playback"]
+});
 var MultipleChoiceOptionSchema = z4.looseObject({
   id: z4.string().min(1),
   text: z4.string().min(1),
   isCorrect: z4.boolean(),
-  feedback: z4.string().optional()
+  feedback: z4.string().optional(),
+  media: MultipleChoiceOptionMediaSchema.optional()
 });
 var MultipleChoiceDataSchema = z4.looseObject({
   schemaVersion: z4.literal("1.0"),
@@ -250,97 +254,243 @@ var MultipleChoiceDataSchema = z4.looseObject({
   path: ["options"]
 });
 
-// src/schemas/written-response.ts
+// src/count-words.ts
+function countWords(text) {
+  if (typeof text !== "string") {
+    return 0;
+  }
+  const trimmed = text.trim();
+  if (trimmed === "") {
+    return 0;
+  }
+  return trimmed.split(/\s+/).length;
+}
+
+// src/schemas/gap-select.ts
 import { z as z5 } from "zod/v4";
-var WrittenResponseRubricCriterionSchema = z5.looseObject({
-  name: z5.string().min(1),
-  description: z5.string().optional(),
-  weight: z5.number().min(0)
-});
-var WrittenResponseRubricSchema = z5.looseObject({
-  label: z5.string().optional(),
-  criteria: z5.array(WrittenResponseRubricCriterionSchema).min(1)
+var GapSelectChoiceSchema = z5.looseObject({
+  id: z5.string().min(1),
+  text: z5.string().min(1)
 });
-var RedactedWrittenResponseRubricCriterionSchema = z5.strictObject({
-  name: z5.string().min(1),
-  description: z5.string().optional(),
-  weight: z5.number().min(0)
+var GapSelectBankSchema = z5.looseObject({
+  id: z5.string().min(1),
+  choices: z5.array(GapSelectChoiceSchema).min(2)
 });
-var RedactedWrittenResponseRubricSchema = z5.strictObject({
-  label: z5.string().optional(),
-  criteria: z5.array(RedactedWrittenResponseRubricCriterionSchema).min(1)
+var GapSelectGapSchema = z5.looseObject({
+  id: z5.string().min(1),
+  choices: z5.array(GapSelectChoiceSchema).min(2).optional(),
+  bankId: z5.string().min(1).optional(),
+  correctChoiceId: z5.string().min(1),
+  feedback: z5.string().optional()
 });
-var WrittenResponseDataSchema = z5.looseObject({
+function resolveChoices(gap, banks) {
+  if (gap.choices !== void 0) {
+    return gap.bankId === void 0 ? gap.choices : void 0;
+  }
+  if (gap.bankId === void 0) {
+    return void 0;
+  }
+  return banks.find((bank) => bank.id === gap.bankId)?.choices;
+}
+function placeholderCounts(passage) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const match of passage.matchAll(PLACEHOLDER_RE)) {
+    const id = match[1];
+    counts.set(id, (counts.get(id) ?? 0) + 1);
+  }
+  return counts;
+}
+var GapSelectDataSchema = z5.looseObject({
   schemaVersion: z5.literal("1.0"),
-  type: z5.literal("written-response"),
+  type: z5.literal("gap-select"),
   id: z5.string().min(1),
   title: z5.string().min(1),
-  prompt: z5.string(),
-  promptHtml: z5.string().optional(),
-  minWords: z5.number().int().min(0),
-  maxWords: z5.number().int().min(1),
-  rubric: WrittenResponseRubricSchema.optional(),
-  languageTarget: z5.string().optional(),
+  passage: z5.string().min(1),
+  passageHtml: z5.string().optional(),
+  gaps: z5.array(GapSelectGapSchema).min(1),
+  banks: z5.array(GapSelectBankSchema).optional(),
+  scoringStrategy: z5.enum(["all-or-nothing", "partial"]),
+  presentation: z5.literal("dropdown").optional(),
+  shuffleChoices: z5.boolean().optional(),
   media: MediaSchema.optional(),
   feedback: FeedbackSchema.optional(),
   passThreshold: z5.number().min(0).max(1).optional(),
   locale: z5.string().optional(),
   learningObjectives: z5.array(z5.string()).optional(),
   difficultyLevel: z5.literal([1, 2, 3, 4, 5]).optional()
+}).refine(
+  (data) => {
+    const ids = (data.banks ?? []).map((bank) => bank.id);
+    return new Set(ids).size === ids.length;
+  },
+  { error: "Word bank ids must be unique.", path: ["banks"] }
+).refine(
+  (data) => {
+    const ids = data.gaps.map((gap) => gap.id);
+    return new Set(ids).size === ids.length;
+  },
+  { error: "Gap ids must be unique.", path: ["gaps"] }
+).refine(
+  (data) => {
+    const counts = placeholderCounts(data.passage);
+    const ids = data.gaps.map((gap) => gap.id);
+    return counts.size === new Set(ids).size && ids.every((id) => counts.get(id) === 1) && [...counts.values()].every((count) => count === 1);
+  },
+  {
+    error: "Every gap must appear exactly once in the passage as {{gap_id}}, and every {{gap_id}} must have a gap.",
+    path: ["passage"]
+  }
+).refine(
+  (data) => data.gaps.every((gap) => gap.choices === void 0 !== (gap.bankId === void 0)),
+  {
+    error: "Each gap needs exactly one choice source: its own `choices`, or a `bankId`.",
+    path: ["gaps"]
+  }
+).refine(
+  (data) => {
+    const bankIds = new Set((data.banks ?? []).map((bank) => bank.id));
+    return data.gaps.every((gap) => gap.bankId === void 0 || bankIds.has(gap.bankId));
+  },
+  { error: "A gap references a `bankId` that no word bank defines.", path: ["gaps"] }
+).refine(
+  (data) => {
+    const banks = data.banks ?? [];
+    return data.gaps.every((gap) => {
+      const choices = resolveChoices(gap, banks);
+      if (choices === void 0) {
+        return true;
+      }
+      const ids = choices.map((choice) => choice.id);
+      return new Set(ids).size === ids.length && ids.includes(gap.correctChoiceId);
+    });
+  },
+  {
+    error: "Each gap needs unique choice ids and a `correctChoiceId` that is one of the choices it offers.",
+    path: ["gaps"]
+  }
+);
+
+// src/schemas/written-response.ts
+import { z as z6 } from "zod/v4";
+var WrittenResponseRubricCriterionSchema = z6.looseObject({
+  name: z6.string().min(1),
+  description: z6.string().optional(),
+  weight: z6.number().min(0)
+});
+var WrittenResponseRubricSchema = z6.looseObject({
+  label: z6.string().optional(),
+  criteria: z6.array(WrittenResponseRubricCriterionSchema).min(1)
+});
+var RedactedWrittenResponseRubricCriterionSchema = z6.strictObject({
+  name: z6.string().min(1),
+  description: z6.string().optional(),
+  weight: z6.number().min(0)
+});
+var RedactedWrittenResponseRubricSchema = z6.strictObject({
+  label: z6.string().optional(),
+  criteria: z6.array(RedactedWrittenResponseRubricCriterionSchema).min(1)
+});
+var WrittenResponseDataSchema = z6.looseObject({
+  schemaVersion: z6.literal("1.0"),
+  type: z6.literal("written-response"),
+  id: z6.string().min(1),
+  title: z6.string().min(1),
+  prompt: z6.string(),
+  promptHtml: z6.string().optional(),
+  minWords: z6.number().int().min(0),
+  maxWords: z6.number().int().min(1),
+  rubric: WrittenResponseRubricSchema.optional(),
+  languageTarget: z6.string().optional(),
+  media: MediaSchema.optional(),
+  feedback: FeedbackSchema.optional(),
+  passThreshold: z6.number().min(0).max(1).optional(),
+  locale: z6.string().optional(),
+  learningObjectives: z6.array(z6.string()).optional(),
+  difficultyLevel: z6.literal([1, 2, 3, 4, 5]).optional()
 }).refine((data) => data.maxWords >= data.minWords, {
   error: "maxWords must be greater than or equal to minWords.",
   path: ["maxWords"]
 });
 
 // src/schemas/redacted.ts
-import { z as z6 } from "zod/v4";
+import { z as z7 } from "zod/v4";
 var redactedBase = {
   /** Marker distinguishing a redacted projection from full activity data. */
-  redacted: z6.literal(true),
+  redacted: z7.literal(true),
   /** Slot identity, carried through redaction so the client and the plan agree. */
-  slotKey: z6.string().min(1).optional(),
-  schemaVersion: z6.literal("1.0"),
-  id: z6.string().min(1),
-  title: z6.string().min(1),
+  slotKey: z7.string().min(1).optional(),
+  schemaVersion: z7.literal("1.0"),
+  id: z7.string().min(1),
+  title: z7.string().min(1),
   media: RedactedMediaSchema.optional(),
-  passThreshold: z6.number().min(0).max(1).optional(),
-  locale: z6.string().optional(),
-  learningObjectives: z6.array(z6.string()).optional(),
-  difficultyLevel: z6.literal([1, 2, 3, 4, 5]).optional()
+  passThreshold: z7.number().min(0).max(1).optional(),
+  locale: z7.string().optional(),
+  learningObjectives: z7.array(z7.string()).optional(),
+  difficultyLevel: z7.literal([1, 2, 3, 4, 5]).optional()
 };
-var RedactedMultipleChoiceOptionSchema = z6.strictObject({
-  id: z6.string().min(1),
-  text: z6.string().min(1)
+var RedactedMultipleChoiceOptionMediaSchema = z7.strictObject({
+  type: z7.enum(["image", "audio"]),
+  url: z7.string().min(1),
+  alt: z7.string().min(1).optional(),
+  captionsUrl: z7.string().min(1).optional()
+});
+var RedactedMultipleChoiceOptionSchema = z7.strictObject({
+  id: z7.string().min(1),
+  text: z7.string().min(1),
+  media: RedactedMultipleChoiceOptionMediaSchema.optional()
 });
-var RedactedMultipleChoiceDataSchema = z6.strictObject({
+var RedactedMultipleChoiceDataSchema = z7.strictObject({
   ...redactedBase,
-  type: z6.literal("multiple-choice"),
-  question: z6.string().min(1),
-  questionHtml: z6.string().optional(),
-  mode: z6.enum(["single", "multi"]),
-  options: z6.array(RedactedMultipleChoiceOptionSchema).min(2).max(26),
-  shuffle: z6.boolean().optional()
+  type: z7.literal("multiple-choice"),
+  question: z7.string().min(1),
+  questionHtml: z7.string().optional(),
+  mode: z7.enum(["single", "multi"]),
+  options: z7.array(RedactedMultipleChoiceOptionSchema).min(2).max(26),
+  shuffle: z7.boolean().optional()
 });
-var RedactedBlankConfigSchema = z6.strictObject({
-  id: z6.string().min(1),
-  hint: z6.string().optional()
+var RedactedBlankConfigSchema = z7.strictObject({
+  id: z7.string().min(1),
+  hint: z7.string().optional()
+});
+var RedactedFillInTheBlanksDataSchema = z7.strictObject({
+  ...redactedBase,
+  type: z7.literal("fill-in-the-blanks"),
+  passage: z7.string().min(1),
+  passageHtml: z7.string().optional(),
+  blanks: z7.array(RedactedBlankConfigSchema).min(1)
+});
+var RedactedGapSelectChoiceSchema = z7.strictObject({
+  id: z7.string().min(1),
+  text: z7.string().min(1)
 });
-var RedactedFillInTheBlanksDataSchema = z6.strictObject({
+var RedactedGapSelectBankSchema = z7.strictObject({
+  id: z7.string().min(1),
+  choices: z7.array(RedactedGapSelectChoiceSchema).min(2)
+});
+var RedactedGapSelectGapSchema = z7.strictObject({
+  id: z7.string().min(1),
+  choices: z7.array(RedactedGapSelectChoiceSchema).min(2).optional(),
+  bankId: z7.string().min(1).optional()
+});
+var RedactedGapSelectDataSchema = z7.strictObject({
   ...redactedBase,
-  type: z6.literal("fill-in-the-blanks"),
-  passage: z6.string().min(1),
-  passageHtml: z6.string().optional(),
-  blanks: z6.array(RedactedBlankConfigSchema).min(1)
+  type: z7.literal("gap-select"),
+  passage: z7.string().min(1),
+  passageHtml: z7.string().optional(),
+  gaps: z7.array(RedactedGapSelectGapSchema).min(1),
+  banks: z7.array(RedactedGapSelectBankSchema).optional(),
+  presentation: z7.literal("dropdown").optional(),
+  shuffleChoices: z7.boolean().optional()
 });
-var RedactedWrittenResponseDataSchema = z6.strictObject({
+var RedactedWrittenResponseDataSchema = z7.strictObject({
   ...redactedBase,
-  type: z6.literal("written-response"),
-  prompt: z6.string(),
-  promptHtml: z6.string().optional(),
-  minWords: z6.number().int().min(0),
-  maxWords: z6.number().int().min(1),
+  type: z7.literal("written-response"),
+  prompt: z7.string(),
+  promptHtml: z7.string().optional(),
+  minWords: z7.number().int().min(0),
+  maxWords: z7.number().int().min(1),
   rubric: RedactedWrittenResponseRubricSchema.optional(),
-  languageTarget: z6.string().optional()
+  languageTarget: z7.string().optional()
 });
 
 // src/scoring/text-match.ts
@@ -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, (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 data.banks?.find((bank) => bank.id === gap.bankId)?.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]));
@@ -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"
   }
 };
@@ -1389,9 +1928,33 @@ 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(response?.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);
 
 export {
   ActivitySchemaError,
@@ -1411,16 +1974,26 @@ export {
   issue,
   isRecord,
   refusesEmpty,
-  countWords,
+  MultipleChoiceOptionMediaSchema,
   MultipleChoiceOptionSchema,
   MultipleChoiceDataSchema,
+  countWords,
+  GapSelectChoiceSchema,
+  GapSelectBankSchema,
+  GapSelectGapSchema,
+  GapSelectDataSchema,
   WrittenResponseRubricCriterionSchema,
   WrittenResponseRubricSchema,
   WrittenResponseDataSchema,
+  RedactedMultipleChoiceOptionMediaSchema,
   RedactedMultipleChoiceOptionSchema,
   RedactedMultipleChoiceDataSchema,
   RedactedBlankConfigSchema,
   RedactedFillInTheBlanksDataSchema,
+  RedactedGapSelectChoiceSchema,
+  RedactedGapSelectBankSchema,
+  RedactedGapSelectGapSchema,
+  RedactedGapSelectDataSchema,
   RedactedWrittenResponseDataSchema,
   levenshteinDistance,
   matchText,
@@ -1433,4 +2006,4 @@ export {
   fillInTheBlanksType,
   writtenResponseType
 };
-//# sourceMappingURL=chunk-AHEUYOT3.js.map
+//# sourceMappingURL=chunk-FIS5KBCE.js.map