@intellectif/lk-core 0.2.1 → 0.3.1

package/dist/chunk-55O4M45K.js

@@ -0,0 +1,57 @@
+import {
+  FillInTheBlanksDataSchema,
+  MultipleChoiceDataSchema,
+  WrittenResponseDataSchema,
+  getActivityTypeDescriptor
+} from "./chunk-5GJJHGY5.js";
+import {
+  UnknownActivityTypeError
+} from "./chunk-3YAVDV5F.js";
+
+// src/schemas/json-schema.ts
+import { z } from "zod/v4";
+var multipleChoiceJsonSchema = z.toJSONSchema(MultipleChoiceDataSchema, {
+  target: "draft-7"
+});
+var fillInTheBlanksJsonSchema = z.toJSONSchema(FillInTheBlanksDataSchema, {
+  target: "draft-7"
+});
+var writtenResponseJsonSchema = z.toJSONSchema(WrittenResponseDataSchema, {
+  target: "draft-7"
+});
+function jsonSchemaFor(type) {
+  const descriptor = getActivityTypeDescriptor(type);
+  if (descriptor === void 0) {
+    throw new UnknownActivityTypeError(type);
+  }
+  return z.toJSONSchema(descriptor.schema, { target: "draft-7" });
+}
+
+// src/schemas/index.ts
+function validateActivity(type, data) {
+  const descriptor = getActivityTypeDescriptor(type);
+  if (descriptor === void 0) {
+    throw new UnknownActivityTypeError(String(type));
+  }
+  const result = descriptor.schema.safeParse(data);
+  if (result.success) {
+    return { success: true, data: result.data };
+  }
+  return {
+    success: false,
+    errors: result.error.issues.map((issue) => ({
+      path: issue.path.map(String),
+      message: issue.message,
+      code: issue.code
+    }))
+  };
+}
+
+export {
+  multipleChoiceJsonSchema,
+  fillInTheBlanksJsonSchema,
+  writtenResponseJsonSchema,
+  jsonSchemaFor,
+  validateActivity
+};
+//# sourceMappingURL=chunk-55O4M45K.js.map

package/dist/chunk-55O4M45K.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/schemas/json-schema.ts","../src/schemas/index.ts"],"sourcesContent":["import { z } from 'zod/v4';\nimport { UnknownActivityTypeError } from '../errors.js';\nimport { getActivityTypeDescriptor } from '../registry/index.js';\nimport { FillInTheBlanksDataSchema } from './fill-in-the-blanks.js';\nimport { MultipleChoiceDataSchema } from './multiple-choice.js';\nimport { WrittenResponseDataSchema } from './written-response.js';\n\n/**\n * JSON Schema (Draft 7) representation of the Multiple Choice activity data\n * contract, generated natively by Zod 4. Draft 7 is mandated by Requirement\n * 2.2 for the widest AI-prompt / OpenAPI tooling compatibility. The semantic\n * `.refine()` guards are not representable in JSON Schema and are\n * intentionally omitted — the export captures the *structural* contract only.\n * Since v0.3 the source schemas are loose, so these no longer emit\n * `additionalProperties: false` — the JSON Schema and `validateActivity` now\n * agree on unknown-key handling.\n */\nexport const multipleChoiceJsonSchema = z.toJSONSchema(MultipleChoiceDataSchema, {\n  target: 'draft-7',\n});\n\n/**\n * JSON Schema (Draft 7) representation of the Fill-in-the-Blanks activity data\n * contract, generated natively by Zod 4. Structural contract only (semantic\n * `.refine()` guards are Zod-only and not representable in JSON Schema).\n */\nexport const fillInTheBlanksJsonSchema = z.toJSONSchema(FillInTheBlanksDataSchema, {\n  target: 'draft-7',\n});\n\n/**\n * JSON Schema (Draft 7) representation of the Written Response activity data\n * contract. Structural contract only.\n */\nexport const writtenResponseJsonSchema = z.toJSONSchema(WrittenResponseDataSchema, {\n  target: 'draft-7',\n});\n\n/**\n * Derives the JSON Schema (Draft 7) for any REGISTERED activity type — the\n * live, registry-backed replacement for the static per-type exports above,\n * and the building block for AI generation pipelines (R6.1): pass the result\n * as a structured-output schema so a model can only emit valid items.\n *\n * @throws UnknownActivityTypeError when `type` has no registered descriptor.\n */\nexport function jsonSchemaFor(type: string): Record<string, unknown> {\n  const descriptor = getActivityTypeDescriptor(type);\n  if (descriptor === undefined) {\n    throw new UnknownActivityTypeError(type);\n  }\n  return z.toJSONSchema(descriptor.schema as never, { target: 'draft-7' }) as Record<\n    string,\n    unknown\n  >;\n}\n","import { UnknownActivityTypeError } from '../errors.js';\nimport { getActivityTypeDescriptor } from '../registry/index.js';\nimport type { ActivityDataMap, ActivityType, ValidationResult } from '../types/activity.js';\n\nexport { FeedbackSchema } from './feedback.js';\nexport {\n  BlankConfigSchema,\n  FillInTheBlanksDataSchema,\n  TextMatchPolicySchema,\n} from './fill-in-the-blanks.js';\nexport {\n  fillInTheBlanksJsonSchema,\n  jsonSchemaFor,\n  multipleChoiceJsonSchema,\n  writtenResponseJsonSchema,\n} from './json-schema.js';\nexport { MediaSchema, MediaUrlSchema } from './media.js';\nexport { MultipleChoiceDataSchema, MultipleChoiceOptionSchema } from './multiple-choice.js';\nexport {\n  RedactedBlankConfigSchema,\n  RedactedFillInTheBlanksDataSchema,\n  RedactedMultipleChoiceDataSchema,\n  RedactedMultipleChoiceOptionSchema,\n  RedactedWrittenResponseDataSchema,\n} from './redacted.js';\nexport {\n  WrittenResponseDataSchema,\n  WrittenResponseRubricCriterionSchema,\n  WrittenResponseRubricSchema,\n} from './written-response.js';\n\n/**\n * Validates raw activity data against the schema registered for the given\n * activity type (built-in or consumer-registered via `registerActivityType`).\n *\n * Unknown keys are PRESERVED, not stripped: every built-in schema is loose,\n * so consumer sidecar fields and forward-version fields survive validation\n * verbatim in the returned `data`.\n *\n * @returns `{ success: true, data }` with the typed, validated data, or\n *          `{ success: false, errors }` with one entry per failed constraint.\n * @throws UnknownActivityTypeError when `type` has no registered descriptor.\n */\nexport function validateActivity<T extends ActivityType>(\n  type: T,\n  data: unknown,\n): ValidationResult<ActivityDataMap[T]> {\n  const descriptor = getActivityTypeDescriptor(type);\n  if (descriptor === undefined) {\n    throw new UnknownActivityTypeError(String(type));\n  }\n\n  const result = descriptor.schema.safeParse(data);\n\n  if (result.success) {\n    return { success: true, data: result.data as ActivityDataMap[T] };\n  }\n\n  return {\n    success: false,\n    errors: result.error.issues.map((issue) => ({\n      path: issue.path.map(String),\n      message: issue.message,\n      code: issue.code,\n    })),\n  };\n}\n"],"mappings":";;;;;;;;;;;AAAA,SAAS,SAAS;AAiBX,IAAM,2BAA2B,EAAE,aAAa,0BAA0B;AAAA,EAC/E,QAAQ;AACV,CAAC;AAOM,IAAM,4BAA4B,EAAE,aAAa,2BAA2B;AAAA,EACjF,QAAQ;AACV,CAAC;AAMM,IAAM,4BAA4B,EAAE,aAAa,2BAA2B;AAAA,EACjF,QAAQ;AACV,CAAC;AAUM,SAAS,cAAc,MAAuC;AACnE,QAAM,aAAa,0BAA0B,IAAI;AACjD,MAAI,eAAe,QAAW;AAC5B,UAAM,IAAI,yBAAyB,IAAI;AAAA,EACzC;AACA,SAAO,EAAE,aAAa,WAAW,QAAiB,EAAE,QAAQ,UAAU,CAAC;AAIzE;;;ACZO,SAAS,iBACd,MACA,MACsC;AACtC,QAAM,aAAa,0BAA0B,IAAI;AACjD,MAAI,eAAe,QAAW;AAC5B,UAAM,IAAI,yBAAyB,OAAO,IAAI,CAAC;AAAA,EACjD;AAEA,QAAM,SAAS,WAAW,OAAO,UAAU,IAAI;AAE/C,MAAI,OAAO,SAAS;AAClB,WAAO,EAAE,SAAS,MAAM,MAAM,OAAO,KAA2B;AAAA,EAClE;AAEA,SAAO;AAAA,IACL,SAAS;AAAA,IACT,QAAQ,OAAO,MAAM,OAAO,IAAI,CAAC,WAAW;AAAA,MAC1C,MAAM,MAAM,KAAK,IAAI,MAAM;AAAA,MAC3B,SAAS,MAAM;AAAA,MACf,MAAM,MAAM;AAAA,IACd,EAAE;AAAA,EACJ;AACF;","names":[]}

package/dist/chunk-5GJJHGY5.js

@@ -0,0 +1,576 @@
+// 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/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 MediaSchema = z2.looseObject({
+  type: z2.enum(["image", "audio", "video", "embed"]),
+  url: MediaUrlSchema,
+  alt: z2.string().min(1).optional(),
+  captionsUrl: MediaUrlSchema.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 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),
+  schemaVersion: z6.literal("1.0"),
+  id: z6.string().min(1),
+  title: z6.string().min(1),
+  media: MediaSchema.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: WrittenResponseRubricSchema.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 && 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) {
+  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 SHARED_PUBLIC_FIELDS = {
+  schemaVersion: "public",
+  type: "public",
+  id: "public",
+  title: "public",
+  media: "public",
+  passThreshold: "public",
+  locale: "public",
+  learningObjectives: "public",
+  difficultyLevel: "public"
+};
+var MULTIPLE_CHOICE_FIELD_POLICY = {
+  ...SHARED_PUBLIC_FIELDS,
+  question: "public",
+  questionHtml: "public",
+  mode: "public",
+  shuffle: "public",
+  scoringStrategy: "answer-key",
+  feedback: "answer-key",
+  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: "answer-key",
+  blanks: {
+    id: "public",
+    hint: "public",
+    acceptedAnswers: "answer-key",
+    caseSensitive: "answer-key",
+    trimWhitespace: "answer-key",
+    match: "answer-key",
+    feedback: "answer-key"
+  }
+};
+var WRITTEN_RESPONSE_FIELD_POLICY = {
+  ...SHARED_PUBLIC_FIELDS,
+  prompt: "public",
+  promptHtml: "public",
+  minWords: "public",
+  maxWords: "public",
+  languageTarget: "public",
+  feedback: "answer-key",
+  // 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 })`.
+  rubric: "public"
+};
+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,
+  FeedbackSchema,
+  MediaUrlSchema,
+  MediaSchema,
+  TextMatchPolicySchema,
+  BlankConfigSchema,
+  FillInTheBlanksDataSchema,
+  MultipleChoiceOptionSchema,
+  MultipleChoiceDataSchema,
+  WrittenResponseRubricCriterionSchema,
+  WrittenResponseRubricSchema,
+  WrittenResponseDataSchema,
+  RedactedMultipleChoiceOptionSchema,
+  RedactedMultipleChoiceDataSchema,
+  RedactedBlankConfigSchema,
+  RedactedFillInTheBlanksDataSchema,
+  RedactedWrittenResponseDataSchema,
+  levenshteinDistance,
+  matchText,
+  defineActivityType,
+  registerActivityType,
+  getActivityTypeDescriptor,
+  registeredActivityTypes,
+  multipleChoiceType,
+  fillInTheBlanksType,
+  writtenResponseType
+};
+//# sourceMappingURL=chunk-5GJJHGY5.js.map