@intellectif/lk-core 0.8.1 → 0.9.0

package/dist/{chunk-FKH4YT5X.cjs → chunk-CVRALNUK.cjs}

@@ -1,16 +1,4 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }// 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
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }// src/errors.ts
 var ActivitySchemaError = class extends Error {
   constructor(activityType, errors) {
     super(`Invalid activity data for type "${activityType}"`);
@@ -211,6 +199,18 @@ var FillInTheBlanksDataSchema = _v4.z.looseObject({
   }
 );
 
+// src/count-words.ts
+function countWords(text) {
+  if (typeof text !== "string") {
+    return 0;
+  }
+  const trimmed = text.trim();
+  if (trimmed === "") {
+    return 0;
+  }
+  return trimmed.split(/\s+/).length;
+}
+
 // src/schemas/multiple-choice.ts
 
 var MultipleChoiceOptionSchema = _v4.z.looseObject({
@@ -455,6 +455,687 @@ 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_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",
+  // 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) {
+  const issues = [];
+  const parsed = MediaSchema.safeParse(media, { reportInput: true });
+  const schemaIssues = parsed.success ? [] : parsed.error.issues.filter((found) => !refusesEmpty(media, found));
+  const refusal = (field) => schemaIssues.find((found) => found.path[0] === field);
+  const typeUnset = isUnwritten(media.type);
+  if (typeUnset) {
+    issues.push(
+      issue("media_type_required", ["media", "type"], "Choose what kind of media this is.")
+    );
+  }
+  if (isUnwritten(media.url)) {
+    issues.push(
+      issue("media_url_required", ["media", "url"], "Add the address of the media file.")
+    );
+  } else {
+    const refused = refusal("url");
+    if (refused !== void 0) {
+      issues.push(
+        issue(
+          "media_url_invalid",
+          ["media", "url"],
+          refused.code === "custom" ? EMBED_URL : URL_POLICY
+        )
+      );
+    }
+  }
+  const needsAlt = media.type === "image" || media.type === "embed";
+  const alt = media.alt;
+  if (needsAlt && isUnwritten(alt) || typeof alt === "string" && alt.trim() === "") {
+    issues.push(
+      issue("media_alt_required", ["media", "alt"], "Add a text description of the media.")
+    );
+  }
+  const captions = media.captionsUrl;
+  if (typeof captions === "string" && captions.trim() === "") {
+    issues.push(
+      issue(
+        "media_url_required",
+        ["media", "captionsUrl"],
+        "Add the address of the captions file, or remove the captions."
+      )
+    );
+  } else if (refusal("captionsUrl") !== void 0) {
+    issues.push(issue("media_url_invalid", ["media", "captionsUrl"], URL_POLICY));
+  }
+  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",
+        ["media", ...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 (e) {
+    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, (_nullishCoalesce(placeholders.get(id), () => ( 0))) + 1);
+  }
+  const blankIds = /* @__PURE__ */ new Map();
+  for (const id of ids) {
+    blankIds.set(id, (_nullishCoalesce(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/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;
+      }
+    }
+    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;
+}
+
+// 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;
@@ -660,7 +1341,8 @@ var multipleChoiceType = defineActivityType({
       data.options.filter((option) => option.isCorrect).map((option) => option.id).join("[,]")
     ]
   },
-  interactions: ["option-selected", "option-deselected", "submitted"]
+  interactions: ["option-selected", "option-deselected", "submitted"],
+  authoring: multipleChoiceAuthoring
 });
 var fillInTheBlanksType = defineActivityType({
   type: "fill-in-the-blanks",
@@ -679,7 +1361,8 @@ var fillInTheBlanksType = defineActivityType({
       data.blanks.map((blank) => _nullishCoalesce(blank.acceptedAnswers[0], () => ( ""))).join("[,]")
     ]
   },
-  interactions: ["blank-filled", "hint-requested", "submitted"]
+  interactions: ["blank-filled", "hint-requested", "submitted"],
+  authoring: fillInTheBlanksAuthoring
 });
 var writtenResponseType = defineActivityType({
   type: "written-response",
@@ -703,7 +1386,8 @@ var writtenResponseType = defineActivityType({
     xapiInteractionType: "long-fill-in",
     correctResponsesPattern: () => []
   },
-  interactions: ["text-changed", "submitted"]
+  interactions: ["text-changed", "submitted"],
+  authoring: writtenResponseAuthoring
 });
 registerActivityType(multipleChoiceType);
 registerActivityType(fillInTheBlanksType);
@@ -744,5 +1428,9 @@ registerActivityType(writtenResponseType);
 
 
 
-exports.countWords = countWords; exports.ActivitySchemaError = ActivitySchemaError; exports.UnknownActivityTypeError = UnknownActivityTypeError; exports.RedactedScoringError = RedactedScoringError; exports.DeferredScoringError = DeferredScoringError; exports.FeedbackSchema = FeedbackSchema; exports.MediaUrlSchema = MediaUrlSchema; exports.NativeControlHintSchema = NativeControlHintSchema; exports.MediaPlaybackSchema = MediaPlaybackSchema; exports.MediaSchema = MediaSchema; exports.RedactedMediaSchema = RedactedMediaSchema; exports.TextMatchPolicySchema = TextMatchPolicySchema; exports.BlankConfigSchema = BlankConfigSchema; exports.FillInTheBlanksDataSchema = FillInTheBlanksDataSchema; exports.MultipleChoiceOptionSchema = MultipleChoiceOptionSchema; exports.MultipleChoiceDataSchema = MultipleChoiceDataSchema; exports.WrittenResponseRubricCriterionSchema = WrittenResponseRubricCriterionSchema; exports.WrittenResponseRubricSchema = WrittenResponseRubricSchema; exports.WrittenResponseDataSchema = WrittenResponseDataSchema; exports.RedactedMultipleChoiceOptionSchema = RedactedMultipleChoiceOptionSchema; exports.RedactedMultipleChoiceDataSchema = RedactedMultipleChoiceDataSchema; exports.RedactedBlankConfigSchema = RedactedBlankConfigSchema; exports.RedactedFillInTheBlanksDataSchema = RedactedFillInTheBlanksDataSchema; exports.RedactedWrittenResponseDataSchema = RedactedWrittenResponseDataSchema; exports.levenshteinDistance = levenshteinDistance; exports.matchText = matchText; exports.defineActivityType = defineActivityType; exports.registerActivityType = registerActivityType; exports.getActivityTypeDescriptor = getActivityTypeDescriptor; exports.registeredActivityTypes = registeredActivityTypes; exports.MEDIA_FIELD_POLICY = MEDIA_FIELD_POLICY; exports.multipleChoiceType = multipleChoiceType; exports.fillInTheBlanksType = fillInTheBlanksType; exports.writtenResponseType = writtenResponseType;
-//# sourceMappingURL=chunk-FKH4YT5X.cjs.map
+
+
+
+
+exports.ActivitySchemaError = ActivitySchemaError; exports.UnknownActivityTypeError = UnknownActivityTypeError; exports.RedactedScoringError = RedactedScoringError; exports.DeferredScoringError = DeferredScoringError; exports.FeedbackSchema = FeedbackSchema; exports.MediaUrlSchema = MediaUrlSchema; exports.NativeControlHintSchema = NativeControlHintSchema; exports.MediaPlaybackSchema = MediaPlaybackSchema; exports.MediaSchema = MediaSchema; exports.RedactedMediaSchema = RedactedMediaSchema; exports.TextMatchPolicySchema = TextMatchPolicySchema; exports.BlankConfigSchema = BlankConfigSchema; exports.FillInTheBlanksDataSchema = FillInTheBlanksDataSchema; exports.DRAFT_ISSUE_SEVERITY = DRAFT_ISSUE_SEVERITY; exports.issue = issue; exports.isRecord = isRecord; exports.refusesEmpty = refusesEmpty; exports.countWords = countWords; exports.MultipleChoiceOptionSchema = MultipleChoiceOptionSchema; exports.MultipleChoiceDataSchema = MultipleChoiceDataSchema; exports.WrittenResponseRubricCriterionSchema = WrittenResponseRubricCriterionSchema; exports.WrittenResponseRubricSchema = WrittenResponseRubricSchema; exports.WrittenResponseDataSchema = WrittenResponseDataSchema; exports.RedactedMultipleChoiceOptionSchema = RedactedMultipleChoiceOptionSchema; exports.RedactedMultipleChoiceDataSchema = RedactedMultipleChoiceDataSchema; exports.RedactedBlankConfigSchema = RedactedBlankConfigSchema; exports.RedactedFillInTheBlanksDataSchema = RedactedFillInTheBlanksDataSchema; exports.RedactedWrittenResponseDataSchema = RedactedWrittenResponseDataSchema; exports.levenshteinDistance = levenshteinDistance; exports.matchText = matchText; exports.defineActivityType = defineActivityType; exports.registerActivityType = registerActivityType; exports.getActivityTypeDescriptor = getActivityTypeDescriptor; exports.registeredActivityTypes = registeredActivityTypes; exports.MEDIA_FIELD_POLICY = MEDIA_FIELD_POLICY; exports.multipleChoiceType = multipleChoiceType; exports.fillInTheBlanksType = fillInTheBlanksType; exports.writtenResponseType = writtenResponseType;
+//# sourceMappingURL=chunk-CVRALNUK.cjs.map