@intellectif/lk-core 0.2.1 → 0.3.1

package/dist/schemas.d.ts

@@ -1,4 +1,4 @@
-import { e as ActivityType, j as ValidationResult, a as ActivityDataMap } from './activity-D5tqgx8A.js';
+import { e as ActivityType, o as ValidationResult, a as ActivityDataMap } from './activity-zdcAMtFB.js';
 import { z } from 'zod/v4';
 
 /**
@@ -9,23 +9,63 @@ import { z } from 'zod/v4';
 declare const FeedbackSchema: z.ZodObject<{
     correct: z.ZodOptional<z.ZodString>;
     incorrect: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>;
+}, z.core.$loose>;
 
-/** Zod schema for a single fill-in-the-blank slot configuration. */
+/**
+ * Zod schema for a `TextMatchPolicy` — the opt-in matching tolerances a blank
+ * may declare. Every default reproduces the v1 trim + case-fold semantics.
+ */
+declare const TextMatchPolicySchema: z.ZodObject<{
+    caseSensitive: z.ZodOptional<z.ZodBoolean>;
+    trim: z.ZodOptional<z.ZodBoolean>;
+    normalize: z.ZodOptional<z.ZodEnum<{
+        none: "none";
+        NFC: "NFC";
+        NFKC: "NFKC";
+    }>>;
+    foldDiacritics: z.ZodOptional<z.ZodBoolean>;
+    collapseInnerWhitespace: z.ZodOptional<z.ZodBoolean>;
+    ignorePunctuation: z.ZodOptional<z.ZodBoolean>;
+    levenshtein: z.ZodOptional<z.ZodNumber>;
+    locale: z.ZodOptional<z.ZodString>;
+}, z.core.$loose>;
+/**
+ * Zod schema for a single fill-in-the-blank slot configuration. Loose:
+ * unknown keys are preserved through validation. Accepted answers must
+ * contain non-whitespace characters — a whitespace-only accepted answer
+ * normalizes to the empty string and would mark an empty response correct.
+ */
 declare const BlankConfigSchema: z.ZodObject<{
     id: z.ZodString;
     acceptedAnswers: z.ZodArray<z.ZodString>;
     caseSensitive: z.ZodOptional<z.ZodBoolean>;
     trimWhitespace: z.ZodOptional<z.ZodBoolean>;
+    match: z.ZodOptional<z.ZodObject<{
+        caseSensitive: z.ZodOptional<z.ZodBoolean>;
+        trim: z.ZodOptional<z.ZodBoolean>;
+        normalize: z.ZodOptional<z.ZodEnum<{
+            none: "none";
+            NFC: "NFC";
+            NFKC: "NFKC";
+        }>>;
+        foldDiacritics: z.ZodOptional<z.ZodBoolean>;
+        collapseInnerWhitespace: z.ZodOptional<z.ZodBoolean>;
+        ignorePunctuation: z.ZodOptional<z.ZodBoolean>;
+        levenshtein: z.ZodOptional<z.ZodNumber>;
+        locale: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>>;
     hint: z.ZodOptional<z.ZodString>;
     feedback: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>;
+}, z.core.$loose>;
 /**
  * Zod schema validating the full Fill-in-the-Blanks activity data contract.
+ * Loose at every level: unknown keys are preserved, never stripped (B7).
  *
- * The refinement enforces a bijection between `{{id}}` placeholders in the
- * passage and `blanks[].id`; otherwise a blank could never be rendered, or a
- * placeholder could have no scoring config, yielding undefined behaviour.
+ * The refinement enforces a true one-to-one correspondence between `{{id}}`
+ * placeholders and `blanks[].id`: every blank id appears EXACTLY ONCE in the
+ * passage and exactly once in `blanks[]`. (The previous set-based check let
+ * duplicate placeholders and duplicate blank configs through, corrupting the
+ * partial-score denominator and per-item details.)
  */
 declare const FillInTheBlanksDataSchema: z.ZodObject<{
     schemaVersion: z.ZodLiteral<"1.0">;
@@ -33,14 +73,29 @@ declare const FillInTheBlanksDataSchema: z.ZodObject<{
     id: z.ZodString;
     title: z.ZodString;
     passage: z.ZodString;
+    passageHtml: z.ZodOptional<z.ZodString>;
     blanks: z.ZodArray<z.ZodObject<{
         id: z.ZodString;
         acceptedAnswers: z.ZodArray<z.ZodString>;
         caseSensitive: z.ZodOptional<z.ZodBoolean>;
         trimWhitespace: z.ZodOptional<z.ZodBoolean>;
+        match: z.ZodOptional<z.ZodObject<{
+            caseSensitive: z.ZodOptional<z.ZodBoolean>;
+            trim: z.ZodOptional<z.ZodBoolean>;
+            normalize: z.ZodOptional<z.ZodEnum<{
+                none: "none";
+                NFC: "NFC";
+                NFKC: "NFKC";
+            }>>;
+            foldDiacritics: z.ZodOptional<z.ZodBoolean>;
+            collapseInnerWhitespace: z.ZodOptional<z.ZodBoolean>;
+            ignorePunctuation: z.ZodOptional<z.ZodBoolean>;
+            levenshtein: z.ZodOptional<z.ZodNumber>;
+            locale: z.ZodOptional<z.ZodString>;
+        }, z.core.$loose>>;
         hint: z.ZodOptional<z.ZodString>;
         feedback: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>>;
+    }, z.core.$loose>>;
     scoringStrategy: z.ZodEnum<{
         "all-or-nothing": "all-or-nothing";
         partial: "partial";
@@ -52,19 +107,19 @@ declare const FillInTheBlanksDataSchema: z.ZodObject<{
             video: "video";
             embed: "embed";
         }>;
-        url: z.ZodURL;
+        url: z.ZodUnion<readonly [z.ZodURL, z.ZodString]>;
         alt: z.ZodOptional<z.ZodString>;
-        captionsUrl: z.ZodOptional<z.ZodURL>;
-    }, z.core.$strip>>;
+        captionsUrl: z.ZodOptional<z.ZodUnion<readonly [z.ZodURL, z.ZodString]>>;
+    }, z.core.$loose>>;
     feedback: z.ZodOptional<z.ZodObject<{
         correct: z.ZodOptional<z.ZodString>;
         incorrect: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>>;
+    }, z.core.$loose>>;
     passThreshold: z.ZodOptional<z.ZodNumber>;
     locale: z.ZodOptional<z.ZodString>;
     learningObjectives: z.ZodOptional<z.ZodArray<z.ZodString>>;
     difficultyLevel: z.ZodOptional<z.ZodLiteral<1 | 2 | 3 | 4 | 5>>;
-}, z.core.$strip>;
+}, z.core.$loose>;
 
 /**
  * JSON Schema (Draft 7) representation of the Multiple Choice activity data
@@ -72,6 +127,9 @@ declare const FillInTheBlanksDataSchema: z.ZodObject<{
  * 2.2 for the widest AI-prompt / OpenAPI tooling compatibility. The semantic
  * `.refine()` guards are not representable in JSON Schema and are
  * intentionally omitted — the export captures the *structural* contract only.
+ * Since v0.3 the source schemas are loose, so these no longer emit
+ * `additionalProperties: false` — the JSON Schema and `validateActivity` now
+ * agree on unknown-key handling.
  */
 declare const multipleChoiceJsonSchema: z.core.JSONSchema.JSONSchema;
 /**
@@ -80,6 +138,20 @@ declare const multipleChoiceJsonSchema: z.core.JSONSchema.JSONSchema;
  * `.refine()` guards are Zod-only and not representable in JSON Schema).
  */
 declare const fillInTheBlanksJsonSchema: z.core.JSONSchema.JSONSchema;
+/**
+ * JSON Schema (Draft 7) representation of the Written Response activity data
+ * contract. Structural contract only.
+ */
+declare const writtenResponseJsonSchema: z.core.JSONSchema.JSONSchema;
+/**
+ * Derives the JSON Schema (Draft 7) for any REGISTERED activity type — the
+ * live, registry-backed replacement for the static per-type exports above,
+ * and the building block for AI generation pipelines (R6.1): pass the result
+ * as a structured-output schema so a model can only emit valid items.
+ *
+ * @throws UnknownActivityTypeError when `type` has no registered descriptor.
+ */
+declare function jsonSchemaFor(type: string): Record<string, unknown>;
 
 /**
  * Optional media attached to an activity, rendered above the question or
@@ -97,6 +169,15 @@ declare const fillInTheBlanksJsonSchema: z.core.JSONSchema.JSONSchema;
  *   (e.g. `https://www.youtube.com/embed/<id>`). `alt` is REQUIRED and used
  *   as the iframe's accessible `title` (WCAG 4.1.2 / 2.4.1).
  */
+/**
+ * Media URL policy (security-reviewed): absolute URLs must use `https:`,
+ * `http:`, `data:`, or `blob:`; root-relative paths (`/media/x.mp3`) are
+ * allowed for same-origin hosting. Everything else — notably `javascript:`,
+ * `file:`, `ftp:` — is rejected: these URLs land in `src` attributes
+ * (including an iframe for `embed`), so an unvetted scheme is a stored-XSS
+ * vector in every consuming app.
+ */
+declare const MediaUrlSchema: z.ZodUnion<readonly [z.ZodURL, z.ZodString]>;
 declare const MediaSchema: z.ZodObject<{
     type: z.ZodEnum<{
         image: "image";
@@ -104,27 +185,35 @@ declare const MediaSchema: z.ZodObject<{
         video: "video";
         embed: "embed";
     }>;
-    url: z.ZodURL;
+    url: z.ZodUnion<readonly [z.ZodURL, z.ZodString]>;
     alt: z.ZodOptional<z.ZodString>;
-    captionsUrl: z.ZodOptional<z.ZodURL>;
-}, z.core.$strip>;
+    captionsUrl: z.ZodOptional<z.ZodUnion<readonly [z.ZodURL, z.ZodString]>>;
+}, z.core.$loose>;
 
-/** Zod schema for a single Multiple Choice option. */
+/**
+ * Zod schema for a single Multiple Choice option. Loose: unknown keys are
+ * preserved through validation (forward-compat / consumer sidecars — B7).
+ */
 declare const MultipleChoiceOptionSchema: z.ZodObject<{
     id: z.ZodString;
     text: z.ZodString;
     isCorrect: z.ZodBoolean;
     feedback: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>;
+}, z.core.$loose>;
 /**
  * Zod schema validating the full Multiple Choice activity data contract.
+ * Loose at every level: unknown keys are preserved, never stripped, so a
+ * v0.3 runtime reading a future payload (or a consumer sidecar field) does
+ * not silently delete data.
  *
- * Two semantic guards: (1) at least one option must be correct, otherwise the
+ * Semantic guards: (1) at least one option must be correct, otherwise the
  * activity can never be answered correctly; (2) `mode: 'single'` must have
  * exactly one correct option — multiple correct options under single-select
  * make `showCorrectAnswers` and the xAPI correct-response ambiguous and mask
- * authoring errors. Both are unrepresentable in JSON Schema and are dropped
- * from `toJSONSchema` output by design.
+ * authoring errors; (3) option ids must be unique — the scorer looks options
+ * up by id, so a duplicate id makes one option unscoreable. All are
+ * unrepresentable in JSON Schema and are dropped from `toJSONSchema` output
+ * by design.
  */
 declare const MultipleChoiceDataSchema: z.ZodObject<{
     schemaVersion: z.ZodLiteral<"1.0">;
@@ -132,6 +221,7 @@ declare const MultipleChoiceDataSchema: z.ZodObject<{
     id: z.ZodString;
     title: z.ZodString;
     question: z.ZodString;
+    questionHtml: z.ZodOptional<z.ZodString>;
     mode: z.ZodEnum<{
         single: "single";
         multi: "multi";
@@ -141,7 +231,7 @@ declare const MultipleChoiceDataSchema: z.ZodObject<{
         text: z.ZodString;
         isCorrect: z.ZodBoolean;
         feedback: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>>;
+    }, z.core.$loose>>;
     scoringStrategy: z.ZodEnum<{
         "all-or-nothing": "all-or-nothing";
         partial: "partial";
@@ -153,27 +243,218 @@ declare const MultipleChoiceDataSchema: z.ZodObject<{
             video: "video";
             embed: "embed";
         }>;
-        url: z.ZodURL;
+        url: z.ZodUnion<readonly [z.ZodURL, z.ZodString]>;
         alt: z.ZodOptional<z.ZodString>;
-        captionsUrl: z.ZodOptional<z.ZodURL>;
-    }, z.core.$strip>>;
+        captionsUrl: z.ZodOptional<z.ZodUnion<readonly [z.ZodURL, z.ZodString]>>;
+    }, z.core.$loose>>;
     feedback: z.ZodOptional<z.ZodObject<{
         correct: z.ZodOptional<z.ZodString>;
         incorrect: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>>;
+    }, z.core.$loose>>;
     passThreshold: z.ZodOptional<z.ZodNumber>;
     shuffle: z.ZodOptional<z.ZodBoolean>;
     locale: z.ZodOptional<z.ZodString>;
     learningObjectives: z.ZodOptional<z.ZodArray<z.ZodString>>;
     difficultyLevel: z.ZodOptional<z.ZodLiteral<1 | 2 | 3 | 4 | 5>>;
-}, z.core.$strip>;
+}, z.core.$loose>;
+
+/** A redacted Multiple Choice option: id and display text only — no `isCorrect`, no feedback. */
+declare const RedactedMultipleChoiceOptionSchema: z.ZodObject<{
+    id: z.ZodString;
+    text: z.ZodString;
+}, z.core.$strict>;
+/**
+ * Redacted Multiple Choice data: renderable (question, mode, options to pick
+ * from) with the answer key, per-option feedback, overall feedback, and the
+ * scoring strategy removed. `scoringStrategy` is answer-key by design: MC
+ * `partial` carries a wrong-selection penalty `all-or-nothing` does not, so
+ * knowing the strategy tells a learner whether guessing is free.
+ */
+declare const RedactedMultipleChoiceDataSchema: z.ZodObject<{
+    type: z.ZodLiteral<"multiple-choice">;
+    question: z.ZodString;
+    questionHtml: z.ZodOptional<z.ZodString>;
+    mode: z.ZodEnum<{
+        single: "single";
+        multi: "multi";
+    }>;
+    options: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        text: z.ZodString;
+    }, z.core.$strict>>;
+    shuffle: z.ZodOptional<z.ZodBoolean>;
+    /** Marker distinguishing a redacted projection from full activity data. */
+    redacted: z.ZodLiteral<true>;
+    schemaVersion: z.ZodLiteral<"1.0">;
+    id: z.ZodString;
+    title: z.ZodString;
+    media: z.ZodOptional<z.ZodObject<{
+        type: z.ZodEnum<{
+            image: "image";
+            audio: "audio";
+            video: "video";
+            embed: "embed";
+        }>;
+        url: z.ZodUnion<readonly [z.ZodURL, z.ZodString]>;
+        alt: z.ZodOptional<z.ZodString>;
+        captionsUrl: z.ZodOptional<z.ZodUnion<readonly [z.ZodURL, z.ZodString]>>;
+    }, z.core.$loose>>;
+    passThreshold: z.ZodOptional<z.ZodNumber>;
+    locale: z.ZodOptional<z.ZodString>;
+    learningObjectives: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    difficultyLevel: z.ZodOptional<z.ZodLiteral<1 | 2 | 3 | 4 | 5>>;
+}, z.core.$strict>;
+/** A redacted blank: id and hint only — no accepted answers, no matching rules, no feedback. */
+declare const RedactedBlankConfigSchema: z.ZodObject<{
+    id: z.ZodString;
+    hint: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+/** Redacted Fill-in-the-Blanks data: passage and blank slots, key removed. */
+declare const RedactedFillInTheBlanksDataSchema: z.ZodObject<{
+    type: z.ZodLiteral<"fill-in-the-blanks">;
+    passage: z.ZodString;
+    passageHtml: z.ZodOptional<z.ZodString>;
+    blanks: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        hint: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    /** Marker distinguishing a redacted projection from full activity data. */
+    redacted: z.ZodLiteral<true>;
+    schemaVersion: z.ZodLiteral<"1.0">;
+    id: z.ZodString;
+    title: z.ZodString;
+    media: z.ZodOptional<z.ZodObject<{
+        type: z.ZodEnum<{
+            image: "image";
+            audio: "audio";
+            video: "video";
+            embed: "embed";
+        }>;
+        url: z.ZodUnion<readonly [z.ZodURL, z.ZodString]>;
+        alt: z.ZodOptional<z.ZodString>;
+        captionsUrl: z.ZodOptional<z.ZodUnion<readonly [z.ZodURL, z.ZodString]>>;
+    }, z.core.$loose>>;
+    passThreshold: z.ZodOptional<z.ZodNumber>;
+    locale: z.ZodOptional<z.ZodString>;
+    learningObjectives: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    difficultyLevel: z.ZodOptional<z.ZodLiteral<1 | 2 | 3 | 4 | 5>>;
+}, z.core.$strict>;
+/**
+ * Redacted Written Response data: the prompt, word bounds and rubric are
+ * learner-visible (a rubric tells the learner what they are graded on);
+ * authored pass/fail feedback is removed until the grade exists.
+ */
+declare const RedactedWrittenResponseDataSchema: z.ZodObject<{
+    type: z.ZodLiteral<"written-response">;
+    prompt: z.ZodString;
+    promptHtml: z.ZodOptional<z.ZodString>;
+    minWords: z.ZodNumber;
+    maxWords: z.ZodNumber;
+    rubric: z.ZodOptional<z.ZodObject<{
+        label: z.ZodOptional<z.ZodString>;
+        criteria: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            description: z.ZodOptional<z.ZodString>;
+            weight: z.ZodNumber;
+        }, z.core.$loose>>;
+    }, z.core.$loose>>;
+    languageTarget: z.ZodOptional<z.ZodString>;
+    /** Marker distinguishing a redacted projection from full activity data. */
+    redacted: z.ZodLiteral<true>;
+    schemaVersion: z.ZodLiteral<"1.0">;
+    id: z.ZodString;
+    title: z.ZodString;
+    media: z.ZodOptional<z.ZodObject<{
+        type: z.ZodEnum<{
+            image: "image";
+            audio: "audio";
+            video: "video";
+            embed: "embed";
+        }>;
+        url: z.ZodUnion<readonly [z.ZodURL, z.ZodString]>;
+        alt: z.ZodOptional<z.ZodString>;
+        captionsUrl: z.ZodOptional<z.ZodUnion<readonly [z.ZodURL, z.ZodString]>>;
+    }, z.core.$loose>>;
+    passThreshold: z.ZodOptional<z.ZodNumber>;
+    locale: z.ZodOptional<z.ZodString>;
+    learningObjectives: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    difficultyLevel: z.ZodOptional<z.ZodLiteral<1 | 2 | 3 | 4 | 5>>;
+}, z.core.$strict>;
 
+/** Zod schema for a single rubric criterion. Loose: unknown keys preserved. */
+declare const WrittenResponseRubricCriterionSchema: z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    weight: z.ZodNumber;
+}, z.core.$loose>;
+/** Zod schema for a written-response grading rubric. Loose: unknown keys preserved. */
+declare const WrittenResponseRubricSchema: z.ZodObject<{
+    label: z.ZodOptional<z.ZodString>;
+    criteria: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        weight: z.ZodNumber;
+    }, z.core.$loose>>;
+}, z.core.$loose>;
 /**
- * Validates raw activity data against the schema for the given activity type.
+ * Zod schema validating the Written Response activity data contract (Req 22).
+ *
+ * Wire-format constraints (Req 22.9): field names are locked for
+ * byte-compatibility with consumer-stored rows, and the schema is loose at
+ * EVERY level (Req 22.5) — unknown top-level keys, `promptHtml`, `rubric`
+ * sidecars and any future fields survive `validateActivity` verbatim.
+ */
+declare const WrittenResponseDataSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"1.0">;
+    type: z.ZodLiteral<"written-response">;
+    id: z.ZodString;
+    title: z.ZodString;
+    prompt: z.ZodString;
+    promptHtml: z.ZodOptional<z.ZodString>;
+    minWords: z.ZodNumber;
+    maxWords: z.ZodNumber;
+    rubric: z.ZodOptional<z.ZodObject<{
+        label: z.ZodOptional<z.ZodString>;
+        criteria: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            description: z.ZodOptional<z.ZodString>;
+            weight: z.ZodNumber;
+        }, z.core.$loose>>;
+    }, z.core.$loose>>;
+    languageTarget: z.ZodOptional<z.ZodString>;
+    media: z.ZodOptional<z.ZodObject<{
+        type: z.ZodEnum<{
+            image: "image";
+            audio: "audio";
+            video: "video";
+            embed: "embed";
+        }>;
+        url: z.ZodUnion<readonly [z.ZodURL, z.ZodString]>;
+        alt: z.ZodOptional<z.ZodString>;
+        captionsUrl: z.ZodOptional<z.ZodUnion<readonly [z.ZodURL, z.ZodString]>>;
+    }, z.core.$loose>>;
+    feedback: z.ZodOptional<z.ZodObject<{
+        correct: z.ZodOptional<z.ZodString>;
+        incorrect: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>>;
+    passThreshold: z.ZodOptional<z.ZodNumber>;
+    locale: z.ZodOptional<z.ZodString>;
+    learningObjectives: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    difficultyLevel: z.ZodOptional<z.ZodLiteral<1 | 2 | 3 | 4 | 5>>;
+}, z.core.$loose>;
+
+/**
+ * Validates raw activity data against the schema registered for the given
+ * activity type (built-in or consumer-registered via `registerActivityType`).
+ *
+ * Unknown keys are PRESERVED, not stripped: every built-in schema is loose,
+ * so consumer sidecar fields and forward-version fields survive validation
+ * verbatim in the returned `data`.
  *
  * @returns `{ success: true, data }` with the typed, validated data, or
  *          `{ success: false, errors }` with one entry per failed constraint.
+ * @throws UnknownActivityTypeError when `type` has no registered descriptor.
  */
 declare function validateActivity<T extends ActivityType>(type: T, data: unknown): ValidationResult<ActivityDataMap[T]>;
 
-export { BlankConfigSchema, FeedbackSchema, FillInTheBlanksDataSchema, MediaSchema, MultipleChoiceDataSchema, MultipleChoiceOptionSchema, fillInTheBlanksJsonSchema, multipleChoiceJsonSchema, validateActivity };
+export { BlankConfigSchema, FeedbackSchema, FillInTheBlanksDataSchema, MediaSchema, MediaUrlSchema, MultipleChoiceDataSchema, MultipleChoiceOptionSchema, RedactedBlankConfigSchema, RedactedFillInTheBlanksDataSchema, RedactedMultipleChoiceDataSchema, RedactedMultipleChoiceOptionSchema, RedactedWrittenResponseDataSchema, TextMatchPolicySchema, WrittenResponseDataSchema, WrittenResponseRubricCriterionSchema, WrittenResponseRubricSchema, fillInTheBlanksJsonSchema, jsonSchemaFor, multipleChoiceJsonSchema, validateActivity, writtenResponseJsonSchema };

package/dist/schemas.js

@@ -1,23 +1,50 @@
+import {
+  fillInTheBlanksJsonSchema,
+  jsonSchemaFor,
+  multipleChoiceJsonSchema,
+  validateActivity,
+  writtenResponseJsonSchema
+} from "./chunk-55O4M45K.js";
 import {
   BlankConfigSchema,
   FeedbackSchema,
   FillInTheBlanksDataSchema,
   MediaSchema,
+  MediaUrlSchema,
   MultipleChoiceDataSchema,
   MultipleChoiceOptionSchema,
-  fillInTheBlanksJsonSchema,
-  multipleChoiceJsonSchema,
-  validateActivity
-} from "./chunk-2T3IL7VL.js";
+  RedactedBlankConfigSchema,
+  RedactedFillInTheBlanksDataSchema,
+  RedactedMultipleChoiceDataSchema,
+  RedactedMultipleChoiceOptionSchema,
+  RedactedWrittenResponseDataSchema,
+  TextMatchPolicySchema,
+  WrittenResponseDataSchema,
+  WrittenResponseRubricCriterionSchema,
+  WrittenResponseRubricSchema
+} from "./chunk-5GJJHGY5.js";
+import "./chunk-3YAVDV5F.js";
 export {
   BlankConfigSchema,
   FeedbackSchema,
   FillInTheBlanksDataSchema,
   MediaSchema,
+  MediaUrlSchema,
   MultipleChoiceDataSchema,
   MultipleChoiceOptionSchema,
+  RedactedBlankConfigSchema,
+  RedactedFillInTheBlanksDataSchema,
+  RedactedMultipleChoiceDataSchema,
+  RedactedMultipleChoiceOptionSchema,
+  RedactedWrittenResponseDataSchema,
+  TextMatchPolicySchema,
+  WrittenResponseDataSchema,
+  WrittenResponseRubricCriterionSchema,
+  WrittenResponseRubricSchema,
   fillInTheBlanksJsonSchema,
+  jsonSchemaFor,
   multipleChoiceJsonSchema,
-  validateActivity
+  validateActivity,
+  writtenResponseJsonSchema
 };
 //# sourceMappingURL=schemas.js.map

package/dist/scoring.cjs

@@ -1,10 +1,20 @@
 "use strict";Object.defineProperty(exports, "__esModule", {value: true});
 
 
-var _chunk3JMLUUFScjs = require('./chunk-3JMLUUFS.cjs');
-require('./chunk-DV466SBJ.cjs');
 
 
+var _chunkTHSZMZNDcjs = require('./chunk-THSZMZND.cjs');
 
-exports.computePassThreshold = _chunk3JMLUUFScjs.computePassThreshold; exports.score = _chunk3JMLUUFScjs.score;
+
+
+var _chunkQOAORTA4cjs = require('./chunk-QOAORTA4.cjs');
+require('./chunk-PIMX4B4D.cjs');
+
+
+
+
+
+
+
+exports.DEFAULT_PASS_THRESHOLD = _chunkTHSZMZNDcjs.DEFAULT_PASS_THRESHOLD; exports.computePassThreshold = _chunkTHSZMZNDcjs.computePassThreshold; exports.evaluate = _chunkTHSZMZNDcjs.evaluate; exports.levenshteinDistance = _chunkQOAORTA4cjs.levenshteinDistance; exports.matchText = _chunkQOAORTA4cjs.matchText; exports.score = _chunkTHSZMZNDcjs.score;
 //# sourceMappingURL=scoring.cjs.map

package/dist/scoring.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["/home/runner/work/learning-kit/learning-kit/packages/lk-core/dist/scoring.cjs"],"names":[],"mappings":"AAAA;AACE;AACA;AACF,wDAA6B;AAC7B,gCAA6B;AAC7B;AACE;AACA;AACF,+GAAC","file":"/home/runner/work/learning-kit/learning-kit/packages/lk-core/dist/scoring.cjs"}
+{"version":3,"sources":["/home/runner/work/learning-kit/learning-kit/packages/lk-core/dist/scoring.cjs"],"names":[],"mappings":"AAAA;AACE;AACA;AACA;AACA;AACF,wDAA6B;AAC7B;AACE;AACA;AACF,wDAA6B;AAC7B,gCAA6B;AAC7B;AACE;AACA;AACA;AACA;AACA;AACA;AACF,+VAAC","file":"/home/runner/work/learning-kit/learning-kit/packages/lk-core/dist/scoring.cjs"}

package/dist/scoring.d.cts

@@ -1,8 +1,11 @@
-import { A as ActivityData, e as ActivityType, L as LearnerResponse, i as ScoringResult } from './activity-D5tqgx8A.cjs';
+import { A as ActivityData, L as LearnerResponse, h as ItemOutcome, e as ActivityType, m as ScoringResult } from './activity-zdcAMtFB.cjs';
+export { T as TextMatchPolicy, n as TextMatchResult, E as levenshteinDistance, G as matchText } from './activity-zdcAMtFB.cjs';
 
+/** Default minimum scaled score required to pass when `passThreshold` is absent. */
+declare const DEFAULT_PASS_THRESHOLD = 0.7;
 /**
  * Returns `true` iff `score` meets or exceeds the activity's `passThreshold`,
- * defaulting to {@link DEFAULT_PASS_THRESHOLD} when the field is absent.
+ * defaulting to {@link DEFAULT_PASS_THRESHOLD} (0.7) when the field is absent.
  */
 declare function computePassThreshold(activityData: ActivityData, score: number): boolean;
 /**
@@ -12,9 +15,30 @@ declare function computePassThreshold(activityData: ActivityData, score: number)
  * Pure and deterministic with no side effects. It does **not** re-validate
  * `activityData` — schema validation is the component boundary's
  * responsibility; this is a low-level scoring primitive that trusts its typed
- * inputs. Dispatches on `activityType`; an unrecognised type throws
- * {@link UnknownActivityTypeError}.
+ * inputs. Dispatch is registry-backed: consumer-registered types with `sync`
+ * scoring work here too. An unregistered type throws
+ * {@link UnknownActivityTypeError}; a type whose grading is deferred (e.g.
+ * `written-response`) throws {@link DeferredScoringError} — use
+ * {@link evaluate}, which can express "not graded yet".
  */
 declare function score(activityType: ActivityType, activityData: ActivityData, learnerResponse: LearnerResponse): ScoringResult;
+/**
+ * Evaluates a learner response against an activity and returns an
+ * {@link ItemOutcome} — the resilient, forward-compatible alternative to
+ * {@link score}:
+ *
+ * - Synchronously graded types return `{ status: 'scored', ... }` with the
+ *   same numbers `score()` produces.
+ * - Asynchronously graded types (e.g. `written-response`) return
+ *   `{ status: 'deferred', reason, partial }` instead of a fake zero — "not
+ *   graded yet" is expressible in the type system, never conflated with
+ *   "wrong".
+ * - An unregistered `data.type` returns `{ status: 'unscorable' }` rather
+ *   than throwing, so a mixed-version content bank cannot crash an exam run.
+ *
+ * The activity type is read from `data.type` — there is no separate type
+ * parameter to disagree with the payload.
+ */
+declare function evaluate(data: ActivityData, response: LearnerResponse): ItemOutcome;
 
-export { computePassThreshold, score };
+export { DEFAULT_PASS_THRESHOLD, computePassThreshold, evaluate, score };

package/dist/scoring.d.ts

@@ -1,8 +1,11 @@
-import { A as ActivityData, e as ActivityType, L as LearnerResponse, i as ScoringResult } from './activity-D5tqgx8A.js';
+import { A as ActivityData, L as LearnerResponse, h as ItemOutcome, e as ActivityType, m as ScoringResult } from './activity-zdcAMtFB.js';
+export { T as TextMatchPolicy, n as TextMatchResult, E as levenshteinDistance, G as matchText } from './activity-zdcAMtFB.js';
 
+/** Default minimum scaled score required to pass when `passThreshold` is absent. */
+declare const DEFAULT_PASS_THRESHOLD = 0.7;
 /**
  * Returns `true` iff `score` meets or exceeds the activity's `passThreshold`,
- * defaulting to {@link DEFAULT_PASS_THRESHOLD} when the field is absent.
+ * defaulting to {@link DEFAULT_PASS_THRESHOLD} (0.7) when the field is absent.
  */
 declare function computePassThreshold(activityData: ActivityData, score: number): boolean;
 /**
@@ -12,9 +15,30 @@ declare function computePassThreshold(activityData: ActivityData, score: number)
  * Pure and deterministic with no side effects. It does **not** re-validate
  * `activityData` — schema validation is the component boundary's
  * responsibility; this is a low-level scoring primitive that trusts its typed
- * inputs. Dispatches on `activityType`; an unrecognised type throws
- * {@link UnknownActivityTypeError}.
+ * inputs. Dispatch is registry-backed: consumer-registered types with `sync`
+ * scoring work here too. An unregistered type throws
+ * {@link UnknownActivityTypeError}; a type whose grading is deferred (e.g.
+ * `written-response`) throws {@link DeferredScoringError} — use
+ * {@link evaluate}, which can express "not graded yet".
  */
 declare function score(activityType: ActivityType, activityData: ActivityData, learnerResponse: LearnerResponse): ScoringResult;
+/**
+ * Evaluates a learner response against an activity and returns an
+ * {@link ItemOutcome} — the resilient, forward-compatible alternative to
+ * {@link score}:
+ *
+ * - Synchronously graded types return `{ status: 'scored', ... }` with the
+ *   same numbers `score()` produces.
+ * - Asynchronously graded types (e.g. `written-response`) return
+ *   `{ status: 'deferred', reason, partial }` instead of a fake zero — "not
+ *   graded yet" is expressible in the type system, never conflated with
+ *   "wrong".
+ * - An unregistered `data.type` returns `{ status: 'unscorable' }` rather
+ *   than throwing, so a mixed-version content bank cannot crash an exam run.
+ *
+ * The activity type is read from `data.type` — there is no separate type
+ * parameter to disagree with the payload.
+ */
+declare function evaluate(data: ActivityData, response: LearnerResponse): ItemOutcome;
 
-export { computePassThreshold, score };
+export { DEFAULT_PASS_THRESHOLD, computePassThreshold, evaluate, score };

package/dist/scoring.js

@@ -1,10 +1,20 @@
 import {
+  DEFAULT_PASS_THRESHOLD,
   computePassThreshold,
+  evaluate,
   score
-} from "./chunk-GZ73G2TS.js";
-import "./chunk-6VOCV4EX.js";
+} from "./chunk-QSVBYTNM.js";
+import {
+  levenshteinDistance,
+  matchText
+} from "./chunk-5GJJHGY5.js";
+import "./chunk-3YAVDV5F.js";
 export {
+  DEFAULT_PASS_THRESHOLD,
   computePassThreshold,
+  evaluate,
+  levenshteinDistance,
+  matchText,
   score
 };
 //# sourceMappingURL=scoring.js.map