@intellectif/lk-core 0.8.2 → 0.10.0

package/dist/chunk-HCOWSGEZ.js

@@ -1,748 +0,0 @@
-// 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/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 placeholderCounts = /* @__PURE__ */ new Map();
-    for (const match of data.passage.matchAll(PLACEHOLDER_RE)) {
-      const id = match[1];
-      placeholderCounts.set(id, (placeholderCounts.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) {
-      return false;
-    }
-    return blankIds.every((id) => placeholderCounts.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 MultipleChoiceOptionSchema = z4.looseObject({
-  id: z4.string().min(1),
-  text: z4.string().min(1),
-  isCorrect: z4.boolean(),
-  feedback: z4.string().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/schemas/written-response.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 RedactedWrittenResponseRubricCriterionSchema = z5.strictObject({
-  name: z5.string().min(1),
-  description: z5.string().optional(),
-  weight: z5.number().min(0)
-});
-var RedactedWrittenResponseRubricSchema = z5.strictObject({
-  label: z5.string().optional(),
-  criteria: z5.array(RedactedWrittenResponseRubricCriterionSchema).min(1)
-});
-var WrittenResponseDataSchema = z5.looseObject({
-  schemaVersion: z5.literal("1.0"),
-  type: z5.literal("written-response"),
-  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(),
-  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) => 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";
-var redactedBase = {
-  /** Marker distinguishing a redacted projection from full activity data. */
-  redacted: z6.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),
-  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()
-};
-var RedactedMultipleChoiceOptionSchema = z6.strictObject({
-  id: z6.string().min(1),
-  text: z6.string().min(1)
-});
-var RedactedMultipleChoiceDataSchema = z6.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()
-});
-var RedactedBlankConfigSchema = z6.strictObject({
-  id: z6.string().min(1),
-  hint: z6.string().optional()
-});
-var RedactedFillInTheBlanksDataSchema = z6.strictObject({
-  ...redactedBase,
-  type: z6.literal("fill-in-the-blanks"),
-  passage: z6.string().min(1),
-  passageHtml: z6.string().optional(),
-  blanks: z6.array(RedactedBlankConfigSchema).min(1)
-});
-var RedactedWrittenResponseDataSchema = z6.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),
-  rubric: RedactedWrittenResponseRubricSchema.optional(),
-  languageTarget: z6.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/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/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"
-  }
-};
-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"]
-});
-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"]
-});
-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"]
-});
-registerActivityType(multipleChoiceType);
-registerActivityType(fillInTheBlanksType);
-registerActivityType(writtenResponseType);
-
-export {
-  countWords,
-  ActivitySchemaError,
-  UnknownActivityTypeError,
-  RedactedScoringError,
-  DeferredScoringError,
-  FeedbackSchema,
-  MediaUrlSchema,
-  NativeControlHintSchema,
-  MediaPlaybackSchema,
-  MediaSchema,
-  RedactedMediaSchema,
-  TextMatchPolicySchema,
-  BlankConfigSchema,
-  FillInTheBlanksDataSchema,
-  MultipleChoiceOptionSchema,
-  MultipleChoiceDataSchema,
-  WrittenResponseRubricCriterionSchema,
-  WrittenResponseRubricSchema,
-  WrittenResponseDataSchema,
-  RedactedMultipleChoiceOptionSchema,
-  RedactedMultipleChoiceDataSchema,
-  RedactedBlankConfigSchema,
-  RedactedFillInTheBlanksDataSchema,
-  RedactedWrittenResponseDataSchema,
-  levenshteinDistance,
-  matchText,
-  defineActivityType,
-  registerActivityType,
-  getActivityTypeDescriptor,
-  registeredActivityTypes,
-  MEDIA_FIELD_POLICY,
-  multipleChoiceType,
-  fillInTheBlanksType,
-  writtenResponseType
-};
-//# sourceMappingURL=chunk-HCOWSGEZ.js.map