@intellectif/lk-core 0.8.2 → 0.10.0

package/dist/chunk-FIS5KBCE.js

@@ -0,0 +1,2009 @@
+// src/errors.ts
+var ActivitySchemaError = class extends Error {
+  constructor(activityType, errors) {
+    super(`Invalid activity data for type "${activityType}"`);
+    this.activityType = activityType;
+    this.errors = errors;
+    this.name = "ActivitySchemaError";
+  }
+  activityType;
+  errors;
+};
+var UnknownActivityTypeError = class extends Error {
+  constructor(activityType) {
+    super(`Activity type "${activityType}" is not registered`);
+    this.activityType = activityType;
+    this.name = "UnknownActivityTypeError";
+  }
+  activityType;
+};
+var RedactedScoringError = class extends Error {
+  constructor(activityType) {
+    super(
+      `Activity data for "${activityType}" carries no answer key (it looks redacted), so it cannot be scored. Score against the full activity data server-side, or use evaluate() which returns { status: "unscorable" }.`
+    );
+    this.activityType = activityType;
+    this.name = "RedactedScoringError";
+  }
+  activityType;
+};
+var DeferredScoringError = class extends Error {
+  constructor(activityType) {
+    super(
+      `Activity type "${activityType}" is graded asynchronously and has no synchronous score. Use evaluate() \u2014 it returns { status: 'deferred' } for this type.`
+    );
+    this.activityType = activityType;
+    this.name = "DeferredScoringError";
+  }
+  activityType;
+};
+
+// src/schemas/feedback.ts
+import { z } from "zod/v4";
+var FeedbackSchema = z.looseObject({
+  correct: z.string().min(1).optional(),
+  incorrect: z.string().min(1).optional()
+});
+
+// src/schemas/media.ts
+import { z as z2 } from "zod/v4";
+var MediaUrlSchema = z2.union([
+  z2.url().refine((value) => /^(https?|data|blob):/i.test(value), {
+    error: "Absolute media URLs must use the https:, http:, data:, or blob: scheme."
+  }),
+  z2.string().regex(/^\/(?!\/)\S*$/, {
+    error: 'Relative media URLs must be root-relative (a single leading "/").'
+  })
+]);
+var NativeControlHintSchema = z2.enum(["hide-download", "hide-rate"]);
+var MediaPlaybackSchema = z2.strictObject({
+  /**
+   * `native` (the resolved default) renders today's `<audio controls>`
+   * unchanged. `minimal` — resolved automatically whenever any enforcement
+   * field is set — replaces the browser bar with the SDK transport:
+   * play/pause, elapsed/total, mute, volume, optional speed, optional
+   * scrubber, and a live plays-remaining status.
+   */
+  controls: z2.enum(["native", "minimal"]).optional(),
+  /**
+   * How many times the recording may be STARTED. A play is consumed when
+   * playback begins from anywhere other than where it last stopped, so
+   * pausing, resuming, and paging between the questions of one listening
+   * group are all free. Enforced in `practice` and `exam`; never in `review`.
+   */
+  maxPlays: z2.number().int().min(1).max(20).optional(),
+  /** `none` renders no scrubber and reverts an out-of-band seek to the high-water mark. */
+  seek: z2.enum(["allow", "none"]).optional(),
+  /** `fixed` renders no speed control and snaps `playbackRate` back to 1. */
+  rate: z2.enum(["allow", "fixed"]).optional(),
+  /** Advisory only. See {@link NativeControlHintSchema}. */
+  nativeControlHints: z2.array(NativeControlHintSchema).min(1).max(2).optional()
+});
+var MediaSchema = z2.looseObject({
+  type: z2.enum(["image", "audio", "video", "embed"]),
+  url: MediaUrlSchema,
+  alt: z2.string().min(1).optional(),
+  captionsUrl: MediaUrlSchema.optional(),
+  playback: MediaPlaybackSchema.optional()
+}).refine(
+  (m) => m.type !== "image" && m.type !== "embed" || typeof m.alt === "string" && m.alt.length > 0,
+  {
+    error: "image and embed media require non-empty alt text (WCAG 1.1.1 / 4.1.2).",
+    path: ["alt"]
+  }
+).refine((m) => m.type !== "embed" || /^https?:\/\//i.test(m.url), {
+  error: "embed media requires an absolute http(s) provider URL. data:, blob:, and relative URLs are not allowed for embeds \u2014 the embed iframe runs with allow-scripts, and a data:/same-origin document there is an XSS vector.",
+  path: ["url"]
+}).refine((m) => m.playback === void 0 || m.type === "audio", {
+  error: "playback policy is supported on audio media only. An embed is a provider iframe the SDK cannot control at all (it has no reliable JS API for a third-party player); an image has nothing to play; video is deliberately deferred, because a video transport must also own fullscreen and Picture-in-Picture and the SDK will not pretend to govern those yet.",
+  path: ["playback"]
+}).refine(
+  (m) => m.playback?.controls !== "native" || m.playback.maxPlays === void 0 && m.playback.seek !== "none" && m.playback.rate !== "fixed",
+  {
+    error: 'controls: "native" cannot carry maxPlays, seek: "none" or rate: "fixed". The browser\'s own bar keeps its play button enabled after a budget is spent, and keeps a scrubber that would move and then silently snap back \u2014 a control that looks operable and does nothing (WCAG 3.2.2 / 4.1.3). Omit `controls` and the SDK transport is used automatically, or use nativeControlHints for a cosmetic hint.',
+    path: ["playback", "controls"]
+  }
+).refine((m) => m.playback?.maxPlays === void 0 || m.playback.seek !== "allow", {
+  error: 'maxPlays cannot be combined with seek: "allow". A play is consumed when playback starts from somewhere other than where it stopped, so scrubbing back mid-play would replay the whole recording without spending anything. Omit `seek` \u2014 it resolves to "none" under a budget.',
+  path: ["playback", "seek"]
+}).refine(
+  (m) => m.playback?.controls !== "minimal" || m.playback.maxPlays !== void 0 || m.playback.seek === "none" || m.playback.rate === "fixed",
+  {
+    error: 'controls: "minimal" with nothing to enforce trades the browser\'s localized, familiar control bar for the SDK\'s, and buys nothing. Set maxPlays, seek: "none" or rate: "fixed", or omit `controls`.',
+    path: ["playback", "controls"]
+  }
+).refine(
+  (m) => m.playback?.nativeControlHints === void 0 || m.playback.controls !== "minimal" && m.playback.maxPlays === void 0 && m.playback.seek !== "none" && m.playback.rate !== "fixed",
+  {
+    error: "nativeControlHints only affects the browser's own control bar, and an enforcing policy replaces that bar with the SDK transport \u2014 so the hints would be silently inert. Use them on an otherwise unrestricted recording, or drop them.",
+    path: ["playback", "nativeControlHints"]
+  }
+);
+var RedactedMediaSchema = z2.strictObject({
+  type: z2.enum(["image", "audio", "video", "embed"]),
+  url: MediaUrlSchema,
+  alt: z2.string().min(1).optional(),
+  captionsUrl: MediaUrlSchema.optional(),
+  playback: MediaPlaybackSchema.optional()
+}).refine(
+  (m) => m.type !== "image" && m.type !== "embed" || typeof m.alt === "string" && m.alt.length > 0,
+  {
+    error: "image and embed media require non-empty alt text (WCAG 1.1.1 / 4.1.2).",
+    path: ["alt"]
+  }
+).refine((m) => m.type !== "embed" || /^https?:\/\//i.test(m.url), {
+  error: "embed media requires an absolute http(s) provider URL. data:, blob:, and relative URLs are not allowed for embeds \u2014 the embed iframe runs with allow-scripts, and a data:/same-origin document there is an XSS vector.",
+  path: ["url"]
+});
+
+// src/schemas/fill-in-the-blanks.ts
+import { z as z3 } from "zod/v4";
+var PLACEHOLDER_RE = /\{\{\s*([^{}]+?)\s*\}\}/g;
+var TextMatchPolicySchema = z3.looseObject({
+  caseSensitive: z3.boolean().optional(),
+  trim: z3.boolean().optional(),
+  normalize: z3.enum(["none", "NFC", "NFKC"]).optional(),
+  foldDiacritics: z3.boolean().optional(),
+  collapseInnerWhitespace: z3.boolean().optional(),
+  ignorePunctuation: z3.boolean().optional(),
+  levenshtein: z3.number().int().min(0).optional(),
+  locale: z3.string().optional()
+});
+var BlankConfigSchema = z3.looseObject({
+  id: z3.string().min(1),
+  acceptedAnswers: z3.array(
+    z3.string().min(1).refine((answer) => answer.trim().length > 0, {
+      error: "Accepted answers must contain non-whitespace characters."
+    })
+  ).min(1),
+  caseSensitive: z3.boolean().optional(),
+  trimWhitespace: z3.boolean().optional(),
+  match: TextMatchPolicySchema.optional(),
+  hint: z3.string().optional(),
+  feedback: z3.string().optional()
+});
+var FillInTheBlanksDataSchema = z3.looseObject({
+  schemaVersion: z3.literal("1.0"),
+  type: z3.literal("fill-in-the-blanks"),
+  id: z3.string().min(1),
+  title: z3.string().min(1),
+  passage: z3.string().min(1),
+  passageHtml: z3.string().optional(),
+  blanks: z3.array(BlankConfigSchema).min(1),
+  scoringStrategy: z3.enum(["all-or-nothing", "partial"]),
+  media: MediaSchema.optional(),
+  feedback: FeedbackSchema.optional(),
+  passThreshold: z3.number().min(0).max(1).optional(),
+  locale: z3.string().optional(),
+  learningObjectives: z3.array(z3.string()).optional(),
+  difficultyLevel: z3.literal([1, 2, 3, 4, 5]).optional()
+}).refine(
+  (data) => {
+    const placeholderCounts2 = /* @__PURE__ */ new Map();
+    for (const match of data.passage.matchAll(PLACEHOLDER_RE)) {
+      const id = match[1];
+      placeholderCounts2.set(id, (placeholderCounts2.get(id) ?? 0) + 1);
+    }
+    const blankIds = data.blanks.map((blank) => blank.id);
+    if (new Set(blankIds).size !== blankIds.length) {
+      return false;
+    }
+    if (placeholderCounts2.size !== blankIds.length) {
+      return false;
+    }
+    return blankIds.every((id) => placeholderCounts2.get(id) === 1);
+  },
+  {
+    error: "Each blank id must appear exactly once in blanks[] and have exactly one matching {{id}} placeholder in the passage, and vice versa.",
+    path: ["passage"]
+  }
+);
+
+// src/schemas/multiple-choice.ts
+import { z as 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(),
+  media: MultipleChoiceOptionMediaSchema.optional()
+});
+var MultipleChoiceDataSchema = z4.looseObject({
+  schemaVersion: z4.literal("1.0"),
+  type: z4.literal("multiple-choice"),
+  id: z4.string().min(1),
+  title: z4.string().min(1),
+  question: z4.string().min(1),
+  questionHtml: z4.string().optional(),
+  mode: z4.enum(["single", "multi"]),
+  options: z4.array(MultipleChoiceOptionSchema).min(2).max(26),
+  scoringStrategy: z4.enum(["all-or-nothing", "partial"]),
+  media: MediaSchema.optional(),
+  feedback: FeedbackSchema.optional(),
+  passThreshold: z4.number().min(0).max(1).optional(),
+  shuffle: z4.boolean().optional(),
+  locale: z4.string().optional(),
+  learningObjectives: z4.array(z4.string()).optional(),
+  difficultyLevel: z4.literal([1, 2, 3, 4, 5]).optional()
+}).refine((data) => data.options.some((option) => option.isCorrect), {
+  error: "At least one option must be marked correct.",
+  path: ["options"]
+}).refine(
+  (data) => data.mode !== "single" || data.options.filter((option) => option.isCorrect).length === 1,
+  {
+    error: 'Single-select activities (mode: "single") must have exactly one correct option.',
+    path: ["options"]
+  }
+).refine((data) => new Set(data.options.map((option) => option.id)).size === data.options.length, {
+  error: "Option ids must be unique within the activity.",
+  path: ["options"]
+});
+
+// src/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 GapSelectChoiceSchema = z5.looseObject({
+  id: z5.string().min(1),
+  text: z5.string().min(1)
+});
+var GapSelectBankSchema = z5.looseObject({
+  id: z5.string().min(1),
+  choices: z5.array(GapSelectChoiceSchema).min(2)
+});
+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()
+});
+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("gap-select"),
+  id: z5.string().min(1),
+  title: z5.string().min(1),
+  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 z7 } from "zod/v4";
+var redactedBase = {
+  /** Marker distinguishing a redacted projection from full activity data. */
+  redacted: z7.literal(true),
+  /** Slot identity, carried through redaction so the client and the plan agree. */
+  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: 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 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 = z7.strictObject({
+  ...redactedBase,
+  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 = 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 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: 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 = z7.strictObject({
+  ...redactedBase,
+  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: z7.string().optional()
+});
+
+// src/scoring/text-match.ts
+var COMBINING_MARKS_RE = /\p{M}/gu;
+var PUNCTUATION_RE = /\p{P}/gu;
+function applyBaseline(value, policy) {
+  let result = value;
+  if (policy.trim !== false) {
+    result = result.trim();
+  }
+  if (policy.caseSensitive !== true) {
+    result = policy.locale ? result.toLocaleLowerCase(policy.locale) : result.toLowerCase();
+  }
+  return result;
+}
+function applyNormalization(value, policy) {
+  let result = value;
+  if (policy.normalize === "NFC" || policy.normalize === "NFKC") {
+    result = result.normalize(policy.normalize);
+  }
+  if (policy.ignorePunctuation === true) {
+    result = result.replace(PUNCTUATION_RE, "");
+  }
+  if (policy.collapseInnerWhitespace === true) {
+    result = result.replace(/(?<=\S)\s+(?=\S)/g, " ");
+    if (policy.trim !== false) {
+      result = result.trim();
+    }
+  }
+  return result;
+}
+function applyDiacriticFold(value) {
+  return value.normalize("NFD").replace(COMBINING_MARKS_RE, "").normalize("NFC");
+}
+function levenshteinDistance(a, b, max) {
+  if (a === b) return 0;
+  if (Math.abs(a.length - b.length) > max) return max + 1;
+  if (a.length === 0) return b.length;
+  if (b.length === 0) return a.length;
+  let previous = Array.from({ length: b.length + 1 }, (_, i) => i);
+  for (let i = 1; i <= a.length; i += 1) {
+    const current = [i];
+    let rowMin = i;
+    for (let j = 1; j <= b.length; j += 1) {
+      const cost = a[i - 1] === b[j - 1] ? 0 : 1;
+      const value = Math.min(
+        previous[j] + 1,
+        current[j - 1] + 1,
+        previous[j - 1] + cost
+      );
+      current.push(value);
+      if (value < rowMin) rowMin = value;
+    }
+    if (rowMin > max) return max + 1;
+    previous = current;
+  }
+  return previous[b.length];
+}
+function matchText(input, accepted, policy = {}) {
+  const acceptedList = typeof accepted === "string" ? [accepted] : accepted;
+  const baselineInput = applyBaseline(input, policy);
+  const baselineAccepted = acceptedList.map((answer) => applyBaseline(answer, policy));
+  if (baselineAccepted.some((answer) => answer === baselineInput)) {
+    return { matched: true, via: "exact" };
+  }
+  const usesNormalization = policy.normalize === "NFC" || policy.normalize === "NFKC" || policy.ignorePunctuation === true || policy.collapseInnerWhitespace === true;
+  const normalizedInput = usesNormalization ? applyNormalization(baselineInput, policy) : baselineInput;
+  const normalizedAccepted = usesNormalization ? baselineAccepted.map((answer) => applyNormalization(answer, policy)) : baselineAccepted;
+  if (usesNormalization && normalizedAccepted.some((answer) => answer === normalizedInput)) {
+    return { matched: true, via: "normalized" };
+  }
+  const foldedInput = policy.foldDiacritics === true ? applyDiacriticFold(normalizedInput) : normalizedInput;
+  const foldedAccepted = policy.foldDiacritics === true ? normalizedAccepted.map((answer) => applyDiacriticFold(answer)) : normalizedAccepted;
+  if (policy.foldDiacritics === true && foldedAccepted.some((answer) => answer === foldedInput)) {
+    return { matched: true, via: "folded" };
+  }
+  const maxDistance = policy.levenshtein ?? 0;
+  if (maxDistance > 0 && foldedInput.trim().length > 0 && foldedAccepted.some(
+    (answer) => levenshteinDistance(foldedInput, answer, maxDistance) <= maxDistance
+  )) {
+    return { matched: true, via: "fuzzy" };
+  }
+  return { matched: false, via: "none" };
+}
+
+// src/registry/registry.ts
+var registry = /* @__PURE__ */ new Map();
+function defineActivityType(descriptor) {
+  return descriptor;
+}
+function registerActivityType(descriptor) {
+  if (descriptor.type === "item-group") {
+    throw new Error(
+      `"item-group" is reserved for the SDK's item-group container (see ItemGroup) and cannot be registered as an activity type.`
+    );
+  }
+  const existing = registry.get(descriptor.type);
+  if (existing !== void 0) {
+    if (existing === descriptor) {
+      return;
+    }
+    throw new Error(
+      `Activity type "${descriptor.type}" is already registered. Registering a different descriptor for an existing type is not allowed.`
+    );
+  }
+  registry.set(descriptor.type, descriptor);
+}
+function getActivityTypeDescriptor(type) {
+  return registry.get(type);
+}
+function registeredActivityTypes() {
+  return [...registry.keys()];
+}
+
+// src/authoring/issues.ts
+var DRAFT_ISSUE_SEVERITY = {
+  // Every registered type — reported by validateDraft itself
+  null_not_allowed: "invalid",
+  // Every built-in activity
+  schema_version_invalid: "invalid",
+  type_mismatch: "invalid",
+  id_required: "invalid",
+  title_required: "incomplete",
+  scoring_strategy_required: "incomplete",
+  pass_threshold_invalid: "invalid",
+  difficulty_level_invalid: "invalid",
+  feedback_empty: "incomplete",
+  redacted_data: "invalid",
+  media_type_required: "incomplete",
+  media_url_required: "incomplete",
+  media_url_invalid: "invalid",
+  media_alt_required: "incomplete",
+  media_playback_invalid: "invalid",
+  media_invalid: "invalid",
+  // multiple-choice
+  mc_question_required: "incomplete",
+  mc_mode_required: "incomplete",
+  mc_options_too_few: "incomplete",
+  mc_options_too_many: "invalid",
+  mc_option_id_required: "invalid",
+  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
+  fib_passage_required: "incomplete",
+  fib_blanks_required: "incomplete",
+  fib_blank_id_required: "invalid",
+  fib_blank_id_duplicate: "invalid",
+  fib_accepted_answers_required: "incomplete",
+  fib_accepted_answer_empty: "incomplete",
+  fib_levenshtein_invalid: "invalid",
+  fib_match_locale_invalid: "invalid",
+  fib_match_invalid: "invalid",
+  fib_blank_missing: "incomplete",
+  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",
+  wr_min_words_invalid: "invalid",
+  wr_max_words_required: "incomplete",
+  wr_max_words_invalid: "invalid",
+  wr_word_bounds_order: "invalid",
+  wr_rubric_criteria_required: "incomplete",
+  wr_criterion_name_required: "incomplete",
+  wr_criterion_weight_required: "incomplete",
+  wr_criterion_weight_invalid: "invalid",
+  wr_rubric_weights_zero: "incomplete",
+  wr_rubric_weights_too_large: "invalid"
+};
+function issue(code, path, message) {
+  return { path: path.map(String), message, code, severity: DRAFT_ISSUE_SEVERITY[code] };
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function valueAt(root, path) {
+  let node = root;
+  for (const segment of path) {
+    if (typeof node !== "object" || node === null) {
+      return void 0;
+    }
+    node = node[segment];
+  }
+  return node;
+}
+function refusesEmpty(root, schemaIssue) {
+  const { path } = schemaIssue;
+  const value = valueAt(root, path);
+  const index = path.at(-1);
+  const list = valueAt(root, path.slice(0, -1));
+  const empty = value === null || value === void 0 && typeof index === "number" && Array.isArray(list) && index < list.length;
+  return empty && (schemaIssue.input === value || schemaIssue.code === "invalid_union");
+}
+function isUnset(value) {
+  return value === void 0 || value === null;
+}
+function isUnwritten(value) {
+  return isUnset(value) || typeof value === "string" && value.trim() === "";
+}
+function isMissingId(value) {
+  return isUnset(value) || value === "";
+}
+function isWholeNumber(value) {
+  return typeof value === "number" && Number.isSafeInteger(value);
+}
+function isTooLarge(value) {
+  return typeof value === "number" && value > Number.MAX_SAFE_INTEGER && Number.isInteger(value);
+}
+function checkIdentity(draft, type) {
+  const issues = [];
+  if (draft.schemaVersion !== "1.0") {
+    issues.push(
+      issue(
+        "schema_version_invalid",
+        ["schemaVersion"],
+        'The draft must have schemaVersion "1.0". A draft from createDraft has it.'
+      )
+    );
+  }
+  if (draft.type !== type) {
+    issues.push(issue("type_mismatch", ["type"], `The draft's type must be "${type}".`));
+  }
+  if (isMissingId(draft.id)) {
+    issues.push(issue("id_required", ["id"], "The activity has no id."));
+  }
+  if (isUnwritten(draft.title)) {
+    issues.push(issue("title_required", ["title"], "Add a title."));
+  }
+  return issues;
+}
+function checkScoringStrategy(draft) {
+  return isUnwritten(draft.scoringStrategy) ? [
+    issue(
+      "scoring_strategy_required",
+      ["scoringStrategy"],
+      "Choose how the question is scored."
+    )
+  ] : [];
+}
+var DIFFICULTY_LEVELS = [1, 2, 3, 4, 5];
+function checkSharedOptional(draft) {
+  const issues = [];
+  const threshold = draft.passThreshold;
+  if (!isUnset(threshold) && !(typeof threshold === "number" && threshold >= 0 && threshold <= 1)) {
+    issues.push(
+      issue(
+        "pass_threshold_invalid",
+        ["passThreshold"],
+        "The pass threshold must be a number from 0 to 1."
+      )
+    );
+  }
+  if (!isUnset(draft.difficultyLevel) && !DIFFICULTY_LEVELS.includes(draft.difficultyLevel)) {
+    issues.push(
+      issue(
+        "difficulty_level_invalid",
+        ["difficultyLevel"],
+        "The difficulty level must be a whole number from 1 to 5."
+      )
+    );
+  }
+  const feedback = draft.feedback;
+  if (isRecord(feedback)) {
+    for (const key of ["correct", "incorrect"]) {
+      const message = feedback[key];
+      if (typeof message === "string" && message.trim() === "") {
+        issues.push(
+          issue("feedback_empty", ["feedback", key], "Write this feedback message, or remove it.")
+        );
+      }
+    }
+  }
+  if (draft.redacted === true) {
+    issues.push(
+      issue(
+        "redacted_data",
+        ["redacted"],
+        "This is a copy prepared for learners, with the answer key removed. Edit the original activity instead."
+      )
+    );
+  }
+  if (isRecord(draft.media)) {
+    issues.push(...checkMedia(draft.media));
+  }
+  return issues;
+}
+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, prefix = ["media"], schema = MediaSchema) {
+  const issues = [];
+  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", at("type"), "Choose what kind of media this is."));
+  }
+  if (isUnwritten(media.url)) {
+    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", 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", 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",
+        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", at("captionsUrl"), URL_POLICY));
+  }
+  for (const schemaIssue of schemaIssues) {
+    const field = schemaIssue.path[0];
+    if (field === "url" || field === "alt" || field === "captionsUrl" || field === "type" && typeUnset) {
+      continue;
+    }
+    issues.push(
+      issue(
+        field === "playback" ? "media_playback_invalid" : "media_invalid",
+        at(...schemaIssue.path.map(String)),
+        schemaIssue.message
+      )
+    );
+  }
+  return issues;
+}
+
+// src/authoring/fill-in-the-blanks.ts
+var fillInTheBlanksAuthoring = {
+  createDraft: ({ newId }) => ({
+    schemaVersion: "1.0",
+    type: "fill-in-the-blanks",
+    id: newId(),
+    title: "",
+    passage: "",
+    blanks: [],
+    scoringStrategy: "all-or-nothing"
+  }),
+  checkDraft: checkFillInTheBlanksDraft
+};
+function checkFillInTheBlanksDraft(draft) {
+  const issues = checkIdentity(draft, "fill-in-the-blanks");
+  const passage = draft.passage;
+  if (isUnwritten(passage)) {
+    issues.push(issue("fib_passage_required", ["passage"], "Write the passage."));
+  }
+  issues.push(...checkScoringStrategy(draft));
+  const blanks = isUnset(draft.blanks) ? [] : draft.blanks;
+  if (Array.isArray(blanks)) {
+    if (blanks.length === 0) {
+      issues.push(
+        issue(
+          "fib_blanks_required",
+          ["blanks"],
+          "Add at least one blank, and mark where it goes in the passage with {{id}}."
+        )
+      );
+    }
+    const ids = [];
+    for (const [index, blank] of blanks.entries()) {
+      if (!isRecord(blank)) {
+        continue;
+      }
+      const name = typeof blank.id === "string" && blank.id !== "" ? `"${blank.id}"` : index + 1;
+      if (isMissingId(blank.id)) {
+        issues.push(
+          issue("fib_blank_id_required", ["blanks", index, "id"], `Blank ${index + 1} has no id.`)
+        );
+      } else if (typeof blank.id === "string") {
+        ids.push(blank.id);
+      }
+      const answers = isUnset(blank.acceptedAnswers) ? [] : blank.acceptedAnswers;
+      if (Array.isArray(answers)) {
+        if (answers.length === 0) {
+          issues.push(
+            issue(
+              "fib_accepted_answers_required",
+              ["blanks", index, "acceptedAnswers"],
+              `Add an accepted answer for blank ${name}.`
+            )
+          );
+        }
+        for (const [position, answer] of answers.entries()) {
+          if (typeof answer === "string" && answer.trim() === "") {
+            issues.push(
+              issue(
+                "fib_accepted_answer_empty",
+                ["blanks", index, "acceptedAnswers", position],
+                `An accepted answer for blank ${name} is empty. Fill it in or remove it.`
+              )
+            );
+          }
+        }
+      }
+      if (isRecord(blank.match)) {
+        issues.push(...checkMatch(blank.match, index));
+      }
+    }
+    if (typeof passage === "string" && passage.trim() !== "") {
+      issues.push(...checkPairing(passage, blanks, ids));
+    }
+  }
+  issues.push(...checkSharedOptional(draft));
+  return issues;
+}
+function checkMatch(match, index) {
+  const issues = [];
+  const at = (...rest) => ["blanks", index, "match", ...rest];
+  const tolerance = match.levenshtein;
+  if (!isUnset(tolerance) && !(isWholeNumber(tolerance) && tolerance >= 0)) {
+    issues.push(
+      issue(
+        "fib_levenshtein_invalid",
+        at("levenshtein"),
+        isTooLarge(tolerance) ? "Typo tolerance is too large." : "Typo tolerance must be a whole number, 0 or more."
+      )
+    );
+  }
+  const locale = match.locale;
+  if (typeof locale === "string" && locale !== "" && !isLanguageTag(locale)) {
+    issues.push(
+      issue(
+        "fib_match_locale_invalid",
+        at("locale"),
+        `"${locale}" is not a language tag. Use one such as "tr" or "en-US", or leave the locale out.`
+      )
+    );
+  }
+  const parsed = TextMatchPolicySchema.safeParse(match, { reportInput: true });
+  if (!parsed.success) {
+    for (const schemaIssue of parsed.error.issues) {
+      if (schemaIssue.path[0] === "levenshtein" || refusesEmpty(match, schemaIssue)) {
+        continue;
+      }
+      issues.push(
+        issue("fib_match_invalid", at(...schemaIssue.path.map(String)), schemaIssue.message)
+      );
+    }
+  }
+  return issues;
+}
+function isLanguageTag(tag) {
+  try {
+    Intl.getCanonicalLocales(tag);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function checkPairing(passage, blanks, ids) {
+  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 blankIds = /* @__PURE__ */ new Map();
+  for (const id of ids) {
+    blankIds.set(id, (blankIds.get(id) ?? 0) + 1);
+  }
+  for (const [id, count] of blankIds) {
+    if (count > 1) {
+      issues.push(
+        issue("fib_blank_id_duplicate", ["passage"], `More than one blank has the id "${id}".`)
+      );
+    }
+  }
+  for (const [id, count] of placeholders) {
+    if (count > 1) {
+      issues.push(
+        issue(
+          "fib_placeholder_duplicate",
+          ["passage"],
+          `{{${id}}} appears more than once in the passage. Each blank goes in one place.`
+        )
+      );
+    }
+    if (!blankIds.has(id)) {
+      issues.push(
+        issue(
+          "fib_blank_missing",
+          ["passage"],
+          `The passage has {{${id}}}, but there is no blank with that id.`
+        )
+      );
+    }
+  }
+  for (const id of blankIds.keys()) {
+    if (!placeholders.has(id)) {
+      issues.push(
+        issue(
+          "fib_placeholder_missing",
+          ["passage"],
+          `Blank "${id}" is not in the passage. Put {{${id}}} where it goes.`
+        )
+      );
+    }
+  }
+  if (issues.length === 0 && !pairsOneToOne(placeholders, blanks)) {
+    issues.push(
+      issue(
+        "fib_blanks_mismatch",
+        ["passage"],
+        "The blanks and the {{id}} placeholders in the passage do not pair up one to one."
+      )
+    );
+  }
+  return issues;
+}
+function pairsOneToOne(placeholders, blanks) {
+  const blankIds = blanks.filter(isRecord).map((blank) => blank.id);
+  if (new Set(blankIds).size !== blankIds.length) {
+    return false;
+  }
+  if (placeholders.size !== blankIds.length) {
+    return false;
+  }
+  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;
+var multipleChoiceAuthoring = {
+  createDraft: ({ newId }) => ({
+    schemaVersion: "1.0",
+    type: "multiple-choice",
+    id: newId(),
+    title: "",
+    question: "",
+    mode: "single",
+    scoringStrategy: "all-or-nothing",
+    options: [
+      { id: newId(), text: "", isCorrect: false },
+      { id: newId(), text: "", isCorrect: false }
+    ]
+  }),
+  checkDraft: checkMultipleChoiceDraft
+};
+function checkMultipleChoiceDraft(draft) {
+  const issues = checkIdentity(draft, "multiple-choice");
+  if (isUnwritten(draft.question)) {
+    issues.push(issue("mc_question_required", ["question"], "Write the question."));
+  }
+  if (isUnwritten(draft.mode)) {
+    issues.push(
+      issue("mc_mode_required", ["mode"], "Choose whether learners select one option or several.")
+    );
+  }
+  issues.push(...checkScoringStrategy(draft));
+  const options = isUnset(draft.options) ? [] : draft.options;
+  if (Array.isArray(options)) {
+    if (options.length < MIN_OPTIONS) {
+      issues.push(issue("mc_options_too_few", ["options"], "Add at least two options."));
+    }
+    if (options.length > MAX_OPTIONS) {
+      issues.push(
+        issue("mc_options_too_many", ["options"], `Use no more than ${MAX_OPTIONS} options.`)
+      );
+    }
+    const seen = /* @__PURE__ */ new Set();
+    const repeated = /* @__PURE__ */ new Set();
+    let correct = 0;
+    for (const [index, option] of options.entries()) {
+      if (!isRecord(option)) {
+        continue;
+      }
+      const ordinal = index + 1;
+      if (isMissingId(option.id)) {
+        issues.push(
+          issue("mc_option_id_required", ["options", index, "id"], `Option ${ordinal} has no id.`)
+        );
+      } else if (typeof option.id === "string") {
+        if (seen.has(option.id)) {
+          repeated.add(option.id);
+        }
+        seen.add(option.id);
+      }
+      if (isUnwritten(option.text)) {
+        issues.push(
+          issue(
+            "mc_option_text_required",
+            ["options", index, "text"],
+            `Write the text of option ${ordinal}.`
+          )
+        );
+      }
+      if (isUnset(option.isCorrect)) {
+        issues.push(
+          issue(
+            "mc_option_correctness_required",
+            ["options", index, "isCorrect"],
+            `Say whether option ${ordinal} is correct.`
+          )
+        );
+      }
+      if (option.isCorrect === true) {
+        correct += 1;
+      }
+      if (isRecord(option.media)) {
+        issues.push(...checkOptionMedia(option.media, index, ordinal));
+      }
+    }
+    for (const id of repeated) {
+      issues.push(
+        issue("mc_option_id_duplicate", ["options"], `More than one option has the id "${id}".`)
+      );
+    }
+    if (correct === 0) {
+      issues.push(
+        issue(
+          "mc_correct_option_required",
+          ["options"],
+          draft.mode === "multi" ? "Mark at least one option as correct." : "Mark the correct option."
+        )
+      );
+    } else if (draft.mode === "single" && correct > 1) {
+      issues.push(
+        issue(
+          "mc_single_mode_one_correct",
+          ["options"],
+          "Only one option can be marked correct when learners select one option."
+        )
+      );
+    }
+  }
+  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 = {
+  createDraft: ({ newId }) => ({
+    schemaVersion: "1.0",
+    type: "written-response",
+    id: newId(),
+    title: "",
+    prompt: "",
+    minWords: 0,
+    maxWords: 0
+  }),
+  checkDraft: checkWrittenResponseDraft
+};
+function checkWrittenResponseDraft(draft) {
+  const issues = checkIdentity(draft, "written-response");
+  if (isUnwritten(draft.prompt)) {
+    issues.push(
+      issue(
+        "wr_prompt_required",
+        ["prompt"],
+        isUnwritten(draft.promptHtml) ? "Write the prompt." : "Write the prompt as plain text too. The rich-text prompt is shown only where a sanitiser is supplied; the plain text is shown everywhere else."
+      )
+    );
+  }
+  const min = draft.minWords;
+  const max = draft.maxWords;
+  if (isUnset(min)) {
+    issues.push(
+      issue(
+        "wr_min_words_required",
+        ["minWords"],
+        "Set the minimum number of words. Use 0 for no minimum."
+      )
+    );
+  } else if (!(isWholeNumber(min) && min >= 0)) {
+    issues.push(
+      issue(
+        "wr_min_words_invalid",
+        ["minWords"],
+        isTooLarge(min) ? "The minimum word count is too large." : "The minimum word count must be a whole number, 0 or more."
+      )
+    );
+  }
+  if (isUnset(max) || max === 0) {
+    issues.push(issue("wr_max_words_required", ["maxWords"], "Set the maximum number of words."));
+  } else if (!(isWholeNumber(max) && max >= 1)) {
+    issues.push(
+      issue(
+        "wr_max_words_invalid",
+        ["maxWords"],
+        isTooLarge(max) ? "The maximum word count is too large." : "The maximum word count must be a whole number, 1 or more."
+      )
+    );
+  } else if (typeof min === "number" && max < min) {
+    issues.push(
+      issue(
+        "wr_word_bounds_order",
+        ["maxWords"],
+        "The maximum word count cannot be lower than the minimum."
+      )
+    );
+  }
+  const rubric = draft.rubric;
+  if (isRecord(rubric)) {
+    const criteria = isUnset(rubric.criteria) ? [] : rubric.criteria;
+    if (Array.isArray(criteria)) {
+      issues.push(...checkCriteria(criteria));
+    }
+  }
+  issues.push(...checkSharedOptional(draft));
+  return issues;
+}
+function checkCriteria(criteria) {
+  const issues = [];
+  if (criteria.length === 0) {
+    issues.push(
+      issue(
+        "wr_rubric_criteria_required",
+        ["rubric", "criteria"],
+        "Add at least one rubric criterion, or remove the rubric."
+      )
+    );
+    return issues;
+  }
+  let totalWeight = 0;
+  let everyWeightUsable = true;
+  for (const [index, criterion] of criteria.entries()) {
+    if (!isRecord(criterion)) {
+      everyWeightUsable = false;
+      continue;
+    }
+    const ordinal = index + 1;
+    const path = ["rubric", "criteria", index];
+    if (isUnwritten(criterion.name)) {
+      issues.push(
+        issue("wr_criterion_name_required", [...path, "name"], `Name rubric criterion ${ordinal}.`)
+      );
+    }
+    const weight = criterion.weight;
+    if (isUnset(weight)) {
+      everyWeightUsable = false;
+      issues.push(
+        issue(
+          "wr_criterion_weight_required",
+          [...path, "weight"],
+          `Give rubric criterion ${ordinal} a weight.`
+        )
+      );
+    } else if (!(typeof weight === "number" && Number.isFinite(weight) && weight >= 0)) {
+      everyWeightUsable = false;
+      issues.push(
+        issue(
+          "wr_criterion_weight_invalid",
+          [...path, "weight"],
+          "A rubric weight must be a number, 0 or more."
+        )
+      );
+    } else {
+      totalWeight += weight;
+    }
+  }
+  if (everyWeightUsable && totalWeight === 0) {
+    issues.push(
+      issue(
+        "wr_rubric_weights_zero",
+        ["rubric", "criteria"],
+        "Give at least one rubric criterion a weight above 0. With every weight at 0, no weighted total can be computed."
+      )
+    );
+  } else if (totalWeight === Number.POSITIVE_INFINITY) {
+    issues.push(
+      issue(
+        "wr_rubric_weights_too_large",
+        ["rubric", "criteria"],
+        "The rubric weights add up to more than can be calculated with. Use smaller weights."
+      )
+    );
+  }
+  return issues;
+}
+
+// src/scoring/strategies/all-or-nothing.ts
+function allOrNothingStrategy(correctItems) {
+  return correctItems.every((isCorrect) => isCorrect) ? 1 : 0;
+}
+
+// src/scoring/strategies/partial.ts
+function partialStrategy(correctSelected, incorrectSelected, totalCorrect, totalIncorrect) {
+  const reward = correctSelected / totalCorrect;
+  const penalty = totalIncorrect === 0 ? 0 : incorrectSelected / totalIncorrect;
+  return Math.max(0, reward - penalty);
+}
+function partialBlankStrategy(correctBlanks, totalBlanks) {
+  return correctBlanks / totalBlanks;
+}
+
+// src/scoring/activity-scorers/fill-in-the-blanks.ts
+function policyFor(blank) {
+  return {
+    ...blank.caseSensitive !== void 0 ? { caseSensitive: blank.caseSensitive } : {},
+    ...blank.trimWhitespace !== void 0 ? { trim: blank.trimWhitespace } : {},
+    ...blank.match
+  };
+}
+function scoreFillInTheBlanks(data, response) {
+  const details = [];
+  const perBlankCorrect = [];
+  for (const blank of data.blanks) {
+    const rawInput = response.answers[blank.id];
+    const input = typeof rawInput === "string" ? rawInput : "";
+    const matched = matchText(input, blank.acceptedAnswers, policyFor(blank)).matched;
+    perBlankCorrect.push(matched);
+    details.push({
+      itemId: blank.id,
+      correct: matched,
+      outcome: matched ? "correct" : "incorrect",
+      learnerResponse: [input],
+      correctResponse: [...blank.acceptedAnswers],
+      weight: 1
+    });
+  }
+  const correctBlanks = perBlankCorrect.filter(Boolean).length;
+  const scoreValue = data.scoringStrategy === "all-or-nothing" ? allOrNothingStrategy(perBlankCorrect) : partialBlankStrategy(correctBlanks, data.blanks.length);
+  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]));
+  const selected = new Set(response.selectedOptionIds);
+  const totalCorrect = data.options.filter((option) => option.isCorrect).length;
+  const totalIncorrect = data.options.length - totalCorrect;
+  let scoreValue;
+  if (data.scoringStrategy === "all-or-nothing") {
+    if (data.mode === "single") {
+      scoreValue = response.selectedOptionIds.length === 1 && optionById.get(response.selectedOptionIds[0])?.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));
+      scoreValue = selected.size === correctIds.length && allCorrectSelected ? 1 : 0;
+    }
+  } else {
+    let correctSelected = 0;
+    let incorrectSelected = 0;
+    for (const id of selected) {
+      const option = optionById.get(id);
+      if (option?.isCorrect) {
+        correctSelected += 1;
+      } else {
+        incorrectSelected += 1;
+      }
+    }
+    scoreValue = partialStrategy(correctSelected, incorrectSelected, totalCorrect, totalIncorrect);
+  }
+  const details = data.options.map((option) => {
+    const wasSelected = selected.has(option.id);
+    const outcome = wasSelected ? option.isCorrect ? "correct" : "incorrect" : option.isCorrect ? "incorrect-omission" : "correct-omission";
+    return {
+      itemId: option.id,
+      correct: wasSelected === option.isCorrect,
+      outcome,
+      learnerResponse: [wasSelected ? "selected" : "not-selected"],
+      correctResponse: [option.isCorrect ? "selected" : "not-selected"],
+      weight: 1
+    };
+  });
+  return { score: scoreValue, maxScore: 1, feedback: null, details };
+}
+
+// src/registry/builtins.ts
+var MEDIA_FIELD_POLICY = {
+  type: "public",
+  url: "public",
+  alt: "public",
+  captionsUrl: "public",
+  playback: {
+    controls: "public",
+    maxPlays: "public",
+    seek: "public",
+    rate: "public",
+    nativeControlHints: "public"
+  }
+};
+var SHARED_PUBLIC_FIELDS = {
+  schemaVersion: "public",
+  type: "public",
+  id: "public",
+  // Assembly metadata, not content: it names the slot this item occupies in a
+  // paper. It has to survive redaction, or the exam client derives positional
+  // slot ids while the server's stored plan holds keyed ones, and the
+  // responses cannot be matched back to the attempt.
+  slotKey: "public",
+  title: "public",
+  media: MEDIA_FIELD_POLICY,
+  passThreshold: "public",
+  locale: "public",
+  learningObjectives: "public",
+  difficultyLevel: "public"
+};
+var FEEDBACK_FIELD_POLICY = {
+  correct: "answer-key",
+  incorrect: "answer-key"
+};
+var TEXT_MATCH_FIELD_POLICY = {
+  caseSensitive: "answer-key",
+  trim: "answer-key",
+  normalize: "answer-key",
+  foldDiacritics: "answer-key",
+  collapseInnerWhitespace: "answer-key",
+  ignorePunctuation: "answer-key",
+  levenshtein: "answer-key",
+  locale: "answer-key"
+};
+var MULTIPLE_CHOICE_FIELD_POLICY = {
+  ...SHARED_PUBLIC_FIELDS,
+  question: "public",
+  questionHtml: "public",
+  mode: "public",
+  shuffle: "public",
+  scoringStrategy: "answer-key",
+  feedback: FEEDBACK_FIELD_POLICY,
+  options: {
+    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"
+  }
+};
+var FILL_IN_THE_BLANKS_FIELD_POLICY = {
+  ...SHARED_PUBLIC_FIELDS,
+  passage: "public",
+  passageHtml: "public",
+  scoringStrategy: "answer-key",
+  feedback: FEEDBACK_FIELD_POLICY,
+  blanks: {
+    id: "public",
+    hint: "public",
+    acceptedAnswers: "answer-key",
+    caseSensitive: "answer-key",
+    trimWhitespace: "answer-key",
+    match: TEXT_MATCH_FIELD_POLICY,
+    feedback: "answer-key"
+  }
+};
+var RUBRIC_FIELD_POLICY = {
+  label: "public",
+  // Applies to every element of the array.
+  criteria: {
+    name: "public",
+    description: "public",
+    weight: "public"
+  }
+};
+var WRITTEN_RESPONSE_FIELD_POLICY = {
+  ...SHARED_PUBLIC_FIELDS,
+  prompt: "public",
+  promptHtml: "public",
+  minWords: "public",
+  maxWords: "public",
+  languageTarget: "public",
+  feedback: FEEDBACK_FIELD_POLICY,
+  // A rubric is a LEARNER affordance, not a grader secret: it tells the
+  // learner what they are being graded on, which is pedagogically the point
+  // of publishing one. (Classifying it author-only broke real deployments
+  // that render a rubric panel during the attempt.) A deployment that wants
+  // it hidden can tighten this per call via `redact(data, { policy })`.
+  // Classified field by field so that stays true of the rubric's DOCUMENTED
+  // fields only — see {@link RUBRIC_FIELD_POLICY}.
+  rubric: RUBRIC_FIELD_POLICY
+};
+var multipleChoiceType = defineActivityType({
+  type: "multiple-choice",
+  // zod4 optional outputs are `T | undefined`; the hand-written wire types use
+  // exact optionals. Structurally identical at runtime — cast is type-level only.
+  schema: MultipleChoiceDataSchema,
+  scoring: { kind: "sync", score: scoreMultipleChoice },
+  isAnswered: (response) => (response?.selectedOptionIds.length ?? 0) > 0,
+  fieldPolicy: MULTIPLE_CHOICE_FIELD_POLICY,
+  redactedSchema: RedactedMultipleChoiceDataSchema,
+  interop: {
+    xapiActivityTypeIri: "http://adlnet.gov/expapi/activities/cmi.interaction",
+    xapiInteractionType: "choice",
+    correctResponsesPattern: (data) => [
+      data.options.filter((option) => option.isCorrect).map((option) => option.id).join("[,]")
+    ]
+  },
+  interactions: ["option-selected", "option-deselected", "submitted"],
+  authoring: multipleChoiceAuthoring
+});
+var fillInTheBlanksType = defineActivityType({
+  type: "fill-in-the-blanks",
+  schema: FillInTheBlanksDataSchema,
+  scoring: { kind: "sync", score: scoreFillInTheBlanks },
+  isAnswered: (response) => Object.values(response?.answers ?? {}).some((answer) => answer.trim().length > 0),
+  fieldPolicy: FILL_IN_THE_BLANKS_FIELD_POLICY,
+  redactedSchema: RedactedFillInTheBlanksDataSchema,
+  interop: {
+    xapiActivityTypeIri: "http://adlnet.gov/expapi/activities/cmi.interaction",
+    xapiInteractionType: "fill-in",
+    // xAPI fill-in pattern: blank answers joined with "[,]". Only the first
+    // accepted answer per blank is emitted (full alternates would explode
+    // combinatorially); the complete key lives in the activity data.
+    correctResponsesPattern: (data) => [
+      data.blanks.map((blank) => blank.acceptedAnswers[0] ?? "").join("[,]")
+    ]
+  },
+  interactions: ["blank-filled", "hint-requested", "submitted"],
+  authoring: fillInTheBlanksAuthoring
+});
+var writtenResponseType = defineActivityType({
+  type: "written-response",
+  schema: WrittenResponseDataSchema,
+  scoring: {
+    kind: "deferred",
+    reason: "requires_async_grading",
+    partial: (data, response) => {
+      const wordCount = countWords(response?.text ?? "");
+      return {
+        withinWordBounds: response !== void 0 && wordCount >= data.minWords && wordCount <= data.maxWords,
+        wordCount
+      };
+    }
+  },
+  isAnswered: (response) => (response?.text.trim().length ?? 0) > 0,
+  fieldPolicy: WRITTEN_RESPONSE_FIELD_POLICY,
+  redactedSchema: RedactedWrittenResponseDataSchema,
+  interop: {
+    xapiActivityTypeIri: "http://adlnet.gov/expapi/activities/cmi.interaction",
+    xapiInteractionType: "long-fill-in",
+    correctResponsesPattern: () => []
+  },
+  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,
+  UnknownActivityTypeError,
+  RedactedScoringError,
+  DeferredScoringError,
+  FeedbackSchema,
+  MediaUrlSchema,
+  NativeControlHintSchema,
+  MediaPlaybackSchema,
+  MediaSchema,
+  RedactedMediaSchema,
+  TextMatchPolicySchema,
+  BlankConfigSchema,
+  FillInTheBlanksDataSchema,
+  DRAFT_ISSUE_SEVERITY,
+  issue,
+  isRecord,
+  refusesEmpty,
+  MultipleChoiceOptionMediaSchema,
+  MultipleChoiceOptionSchema,
+  MultipleChoiceDataSchema,
+  countWords,
+  GapSelectChoiceSchema,
+  GapSelectBankSchema,
+  GapSelectGapSchema,
+  GapSelectDataSchema,
+  WrittenResponseRubricCriterionSchema,
+  WrittenResponseRubricSchema,
+  WrittenResponseDataSchema,
+  RedactedMultipleChoiceOptionMediaSchema,
+  RedactedMultipleChoiceOptionSchema,
+  RedactedMultipleChoiceDataSchema,
+  RedactedBlankConfigSchema,
+  RedactedFillInTheBlanksDataSchema,
+  RedactedGapSelectChoiceSchema,
+  RedactedGapSelectBankSchema,
+  RedactedGapSelectGapSchema,
+  RedactedGapSelectDataSchema,
+  RedactedWrittenResponseDataSchema,
+  levenshteinDistance,
+  matchText,
+  defineActivityType,
+  registerActivityType,
+  getActivityTypeDescriptor,
+  registeredActivityTypes,
+  MEDIA_FIELD_POLICY,
+  multipleChoiceType,
+  fillInTheBlanksType,
+  writtenResponseType
+};
+//# sourceMappingURL=chunk-FIS5KBCE.js.map