@intellectif/lk-core 0.5.0 → 0.7.0

package/dist/chunk-XL75ZZVM.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/schemas/item-group.ts","../src/schemas/json-schema.ts","../src/schemas/index.ts"],"sourcesContent":["import { z } from 'zod/v4';\nimport { getActivityTypeDescriptor } from '../registry/index.js';\nimport type { ActivityData, ValidationError, ValidationResult } from '../types/activity.js';\nimport type { ItemGroup, StimulusKind } from '../types/item-group.js';\nimport { MediaSchema } from './media.js';\n\nfunction hasBody(stimulus: { body?: string | undefined }): boolean {\n  return typeof stimulus.body === 'string' && stimulus.body.trim().length > 0;\n}\n\n/** Which media types can carry a stimulus of each kind. `text`/`mixed` accept any. */\nfunction mediaFits(kind: StimulusKind, mediaType: string | undefined): boolean {\n  switch (kind) {\n    case 'audio':\n      return mediaType === 'audio';\n    case 'video':\n      return mediaType === 'video' || mediaType === 'embed';\n    case 'image':\n      return mediaType === 'image';\n    default:\n      return true;\n  }\n}\n\n/**\n * Zod schema for a {@link Stimulus}. Loose: unknown keys preserved.\n *\n * The semantic guards exist because a stimulus that does not carry what its\n * `kind` promises is an authoring error that must not reach an exam: an\n * \"audio\" stimulus with no recording renders as a blank panel above six\n * listening questions. Unrepresentable in JSON Schema; dropped from\n * `stimulusJsonSchema` by design.\n */\nexport const StimulusSchema = z\n  .looseObject({\n    id: z.string().min(1),\n    kind: z.enum(['text', 'audio', 'video', 'image', 'mixed']),\n    title: z.string().optional(),\n    body: z.string().optional(),\n    bodyHtml: z.string().optional(),\n    media: MediaSchema.optional(),\n    transcript: z.string().optional(),\n    locale: z.string().optional(),\n    attribution: z.string().optional(),\n  })\n  .refine((stimulus) => stimulus.bodyHtml === undefined || hasBody(stimulus), {\n    error:\n      'bodyHtml requires a plain-text body: it is the accessible fallback rendered when no sanitiser is supplied.',\n    path: ['body'],\n  })\n  .refine(\n    (stimulus) => (stimulus.kind !== 'text' && stimulus.kind !== 'mixed') || hasBody(stimulus),\n    {\n      error: 'A text or mixed stimulus needs a non-empty body.',\n      path: ['body'],\n    },\n  )\n  .refine((stimulus) => stimulus.kind === 'text' || stimulus.media !== undefined, {\n    error: 'An audio, video, image or mixed stimulus needs media.',\n    path: ['media'],\n  })\n  .refine(\n    (stimulus) => stimulus.media === undefined || mediaFits(stimulus.kind, stimulus.media.type),\n    {\n      error:\n        'media.type does not fit the stimulus kind: audio needs audio; video needs video or embed; image needs image.',\n      path: ['media', 'type'],\n    },\n  );\n\n/**\n * The structural minimum of an item as seen by the CONTAINER schema. Each\n * item's own contract is checked against its registered schema by\n * {@link validateItemGroup} — a zod schema cannot dispatch on a registry\n * that consumers extend at runtime.\n */\nconst ItemShapeSchema = z.looseObject({\n  type: z.string().min(1),\n  id: z.string().min(1),\n  slotKey: z.string().min(1).optional(),\n});\n\n/**\n * Zod schema for an {@link ItemGroup} CONTAINER. Loose: unknown keys\n * preserved. Validates the group's own fields and the stimulus in full, and\n * each item only structurally (`type` and `id`); use {@link validateItemGroup}\n * to validate the items against their registered schemas as well.\n */\nexport const ItemGroupSchema = z\n  .looseObject({\n    schemaVersion: z.literal('1.0'),\n    type: z.literal('item-group'),\n    id: z.string().min(1),\n    title: z.string().optional(),\n    slotKey: z.string().min(1).optional(),\n    stimulus: StimulusSchema,\n    items: z.array(ItemShapeSchema).min(1),\n    shuffle: z.enum(['none', 'within-group']).optional(),\n  })\n  .refine((group) => group.items.every((item) => item.type !== 'item-group'), {\n    error: 'Item groups do not nest: every item must be an activity.',\n    path: ['items'],\n  })\n  .refine((group) => new Set(group.items.map((item) => item.id)).size === group.items.length, {\n    error: 'Item ids must be unique within a group.',\n    path: ['items'],\n  });\n\n/** The learner-safe shape of a stimulus, derived from the strict schema below. */\nexport type RedactedStimulus = z.infer<typeof RedactedStimulusSchema>;\n\n/** Strict learner-safe stimulus: everything but the author-only `transcript`. */\nexport const RedactedStimulusSchema = z.strictObject({\n  id: z.string().min(1),\n  kind: z.enum(['text', 'audio', 'video', 'image', 'mixed']),\n  title: z.string().optional(),\n  body: z.string().optional(),\n  bodyHtml: z.string().optional(),\n  media: MediaSchema.optional(),\n  locale: z.string().optional(),\n  attribution: z.string().optional(),\n});\n\n/**\n * Strict learner-safe item group. Items are left opaque here — each is proven\n * learner-safe by `assertRedacted` against its OWN type's redacted schema,\n * which is the only place that knowledge lives.\n */\nexport const RedactedItemGroupSchema = z.strictObject({\n  redacted: z.literal(true),\n  schemaVersion: z.literal('1.0'),\n  type: z.literal('item-group'),\n  id: z.string().min(1),\n  title: z.string().optional(),\n  slotKey: z.string().min(1).optional(),\n  stimulus: RedactedStimulusSchema,\n  items: z.array(z.unknown()).min(1),\n  shuffle: z.enum(['none', 'within-group']).optional(),\n});\n\nfunction toValidationErrors(\n  issues: readonly { path: PropertyKey[]; message: string; code: string }[],\n  prefix: string[],\n): ValidationError[] {\n  return issues.map((issue) => ({\n    path: [...prefix, ...issue.path.map(String)],\n    message: issue.message,\n    code: issue.code,\n  }));\n}\n\n/**\n * Validates an item group in full: the container and stimulus against\n * {@link ItemGroupSchema}, then every item against the schema registered for\n * its `type`. Errors from items are reported at `items.<index>.…`.\n *\n * Unlike `validateActivity`, an item whose type is not registered is REPORTED\n * (code `unknown_activity_type`) rather than thrown: a group is validated as\n * a whole, and an author fixing a six-item group wants every problem listed,\n * not the first one that happened to throw.\n */\nexport function validateItemGroup(data: unknown): ValidationResult<ItemGroup> {\n  const container = ItemGroupSchema.safeParse(data);\n  if (!container.success) {\n    return { success: false, errors: toValidationErrors(container.error.issues, []) };\n  }\n\n  const errors: ValidationError[] = [];\n  const items: ActivityData[] = [];\n  container.data.items.forEach((item, index) => {\n    const descriptor = getActivityTypeDescriptor(item.type);\n    if (descriptor === undefined) {\n      errors.push({\n        path: ['items', String(index), 'type'],\n        message: `Activity type \"${item.type}\" is not registered`,\n        code: 'unknown_activity_type',\n      });\n      return;\n    }\n    const parsed = descriptor.schema.safeParse(item);\n    if (!parsed.success) {\n      errors.push(...toValidationErrors(parsed.error.issues, ['items', String(index)]));\n      return;\n    }\n    items.push(parsed.data as ActivityData);\n  });\n\n  if (errors.length > 0) {\n    return { success: false, errors };\n  }\n  // zod4 optional outputs are `T | undefined`; the wire type uses exact\n  // optionals. Structurally identical at runtime — the cast is type-level.\n  return { success: true, data: { ...container.data, items } as unknown as ItemGroup };\n}\n","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 { ItemGroupSchema, StimulusSchema } from './item-group.js';\nimport { MultipleChoiceDataSchema } from './multiple-choice.js';\nimport { WrittenResponseDataSchema } from './written-response.js';\n\n/**\n * JSON Schema (Draft 7) for a `Stimulus`. Structural contract only — the\n * kind/media/body consistency guards are Zod-only.\n */\nexport const stimulusJsonSchema = z.toJSONSchema(StimulusSchema, { target: 'draft-7' });\n\n/**\n * JSON Schema (Draft 7) for an `ItemGroup` CONTAINER. Items appear as objects\n * with `type` and `id` only; each item's own contract is `jsonSchemaFor(type)`.\n * For an AI generation pipeline, ask for the group and each item separately\n * rather than a single nested schema — that keeps the per-type schema the\n * registry's, not a copy.\n */\nexport const itemGroupJsonSchema = z.toJSONSchema(ItemGroupSchema, { target: 'draft-7' });\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 type { RedactedStimulus } from './item-group.js';\nexport {\n  ItemGroupSchema,\n  RedactedItemGroupSchema,\n  RedactedStimulusSchema,\n  StimulusSchema,\n  validateItemGroup,\n} from './item-group.js';\nexport {\n  fillInTheBlanksJsonSchema,\n  itemGroupJsonSchema,\n  jsonSchemaFor,\n  multipleChoiceJsonSchema,\n  stimulusJsonSchema,\n  writtenResponseJsonSchema,\n} from './json-schema.js';\nexport { MediaSchema, MediaUrlSchema } from './media.js';\nexport { MultipleChoiceDataSchema, MultipleChoiceOptionSchema } from './multiple-choice.js';\nexport type {\n  RedactedActivity,\n  RedactedBlankConfig,\n  RedactedFillInTheBlanksData,\n  RedactedMultipleChoiceData,\n  RedactedMultipleChoiceOption,\n  RedactedWrittenResponseData,\n} from './redacted.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":"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","names":["z","z"]}

package/dist/{chunk-NUCEUU4P.js → chunk-YCXIHFLG.js}

@@ -223,6 +223,8 @@ 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),
@@ -472,6 +474,11 @@ 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: "public",
   passThreshold: "public",
@@ -622,4 +629,4 @@ export {
   fillInTheBlanksType,
   writtenResponseType
 };
-//# sourceMappingURL=chunk-NUCEUU4P.js.map
+//# sourceMappingURL=chunk-YCXIHFLG.js.map

package/dist/chunk-YCXIHFLG.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/count-words.ts","../src/errors.ts","../src/schemas/feedback.ts","../src/schemas/media.ts","../src/schemas/fill-in-the-blanks.ts","../src/schemas/multiple-choice.ts","../src/schemas/written-response.ts","../src/schemas/redacted.ts","../src/scoring/text-match.ts","../src/registry/registry.ts","../src/scoring/strategies/all-or-nothing.ts","../src/scoring/strategies/partial.ts","../src/scoring/activity-scorers/fill-in-the-blanks.ts","../src/scoring/activity-scorers/multiple-choice.ts","../src/registry/builtins.ts"],"sourcesContent":["/**\n * Canonical word counter for written-response bounds (Req 22.9): tokens are\n * maximal runs of non-whitespace (split on `\\s+`), so hyphenated forms\n * (`well-known`) count as one word. The empty / whitespace-only string counts\n * 0. Consumers must use this helper rather than re-implementing the split so\n * client previews, SDK scoring, and stored `wordCount` values always agree.\n */\nexport function countWords(text: string): number {\n  // Tolerate non-strings: this runs on client-supplied submission payloads,\n  // where a malformed value must score 0 rather than throw mid-grading.\n  if (typeof text !== 'string') {\n    return 0;\n  }\n  const trimmed = text.trim();\n  if (trimmed === '') {\n    return 0;\n  }\n  return trimmed.split(/\\s+/).length;\n}\n","import type { ValidationError } from './types/activity.js';\n\n/** Thrown when activity data fails schema validation at a component boundary. */\nexport class ActivitySchemaError extends Error {\n  constructor(\n    public readonly activityType: string,\n    public readonly errors: ValidationError[],\n  ) {\n    super(`Invalid activity data for type \"${activityType}\"`);\n    this.name = 'ActivitySchemaError';\n  }\n}\n\n/** Thrown when an unrecognised activity type is passed to the scoring engine. */\nexport class UnknownActivityTypeError extends Error {\n  constructor(public readonly activityType: string) {\n    super(`Activity type \"${activityType}\" is not registered`);\n    this.name = 'UnknownActivityTypeError';\n  }\n}\n\n/**\n * Thrown when `score()` is asked to grade a `redact()` projection (or any\n * activity data whose answer key is missing, yielding a non-finite score).\n * Redacted data is learner-safe precisely because the key was removed, so a\n * score derived from it is meaningless — previously this produced a silent\n * `NaN` that serialized to `null` in a grade column. `evaluate()` returns\n * `{ status: 'unscorable' }` for the same input instead of throwing.\n */\nexport class RedactedScoringError extends Error {\n  constructor(public readonly activityType: string) {\n    super(\n      `Activity data for \"${activityType}\" carries no answer key (it looks redacted), so it cannot be scored. ` +\n        'Score against the full activity data server-side, or use evaluate() which returns { status: \"unscorable\" }.',\n    );\n    this.name = 'RedactedScoringError';\n  }\n}\n\n/**\n * Thrown when `score()` is called for an activity type whose grading is\n * deferred (asynchronous AI/human grading, e.g. `written-response`). A\n * deferred submission has no synchronous score — treating it as 0 would show\n * a learner a failing grade for work that simply has not been graded yet.\n * Call `evaluate()` instead, which returns `{ status: 'deferred', ... }`.\n */\nexport class DeferredScoringError extends Error {\n  constructor(public readonly activityType: string) {\n    super(\n      `Activity type \"${activityType}\" is graded asynchronously and has no synchronous score. ` +\n        `Use evaluate() — it returns { status: 'deferred' } for this type.`,\n    );\n    this.name = 'DeferredScoringError';\n  }\n}\n","import { z } from 'zod/v4';\n\n/**\n * Optional authored \"overall feedback\" shown after submission, selected by\n * whether the learner passed (h5p-style overall feedback). Both fields are\n * optional; non-empty when present.\n */\nexport const FeedbackSchema = z.looseObject({\n  correct: z.string().min(1).optional(),\n  incorrect: z.string().min(1).optional(),\n});\n","import { z } from 'zod/v4';\n\n/**\n * Optional media attached to an activity, rendered above the question or\n * passage — e.g. a recording to listen to, or an embedded video to watch\n * before answering. URL-only by design: hosting/delivery (S3/CDN, or the\n * provider's own embed for `embed`) is the consuming app's responsibility\n * (see requirements \"Non-Goals and Shared Responsibility\").\n *\n * - `image`: rendered as `<img>` — `alt` is REQUIRED (WCAG 1.1.1 / Req 14.5).\n * - `audio` / `video`: rendered with native controls; `alt` is an optional\n *   accessible label; `captionsUrl` points at a WebVTT `<track>`. `url` must\n *   be a direct media file (NOT a YouTube/Vimeo page — use `embed` for those).\n * - `embed`: rendered as a sandboxed `<iframe>` for provider players\n *   (YouTube/Vimeo/etc.). `url` MUST be the provider's *embeddable* URL\n *   (e.g. `https://www.youtube.com/embed/<id>`). `alt` is REQUIRED and used\n *   as the iframe's accessible `title` (WCAG 4.1.2 / 2.4.1).\n */\n/**\n * Media URL policy (security-reviewed): absolute URLs must use `https:`,\n * `http:`, `data:`, or `blob:`; root-relative paths (`/media/x.mp3`) are\n * allowed for same-origin hosting. Everything else — notably `javascript:`,\n * `file:`, `ftp:` — is rejected: these URLs land in `src` attributes\n * (including an iframe for `embed`), so an unvetted scheme is a stored-XSS\n * vector in every consuming app.\n */\nexport const MediaUrlSchema = z.union([\n  z.url().refine((value) => /^(https?|data|blob):/i.test(value), {\n    error: 'Absolute media URLs must use the https:, http:, data:, or blob: scheme.',\n  }),\n  z.string().regex(/^\\/(?!\\/)\\S*$/, {\n    error: 'Relative media URLs must be root-relative (a single leading \"/\").',\n  }),\n]);\n\nexport const MediaSchema = z\n  .looseObject({\n    type: z.enum(['image', 'audio', 'video', 'embed']),\n    url: MediaUrlSchema,\n    alt: z.string().min(1).optional(),\n    captionsUrl: MediaUrlSchema.optional(),\n  })\n  .refine(\n    (m) =>\n      (m.type !== 'image' && m.type !== 'embed') || (typeof m.alt === 'string' && m.alt.length > 0),\n    {\n      error: 'image and embed media require non-empty alt text (WCAG 1.1.1 / 4.1.2).',\n      path: ['alt'],\n    },\n  )\n  .refine((m) => m.type !== 'embed' || /^https?:\\/\\//i.test(m.url), {\n    error:\n      'embed media requires an absolute http(s) provider URL. data:, blob:, and relative URLs are not allowed for embeds — the embed iframe runs with allow-scripts, and a data:/same-origin document there is an XSS vector.',\n    path: ['url'],\n  });\n","import { z } from 'zod/v4';\nimport { FeedbackSchema } from './feedback.js';\nimport { MediaSchema } from './media.js';\n\n/** Matches `{{ blank_id }}` placeholders in a passage, capturing the trimmed id. */\nconst PLACEHOLDER_RE = /\\{\\{\\s*([^{}]+?)\\s*\\}\\}/g;\n\n/**\n * Zod schema for a `TextMatchPolicy` — the opt-in matching tolerances a blank\n * may declare. Every default reproduces the v1 trim + case-fold semantics.\n */\nexport const TextMatchPolicySchema = z.looseObject({\n  caseSensitive: z.boolean().optional(),\n  trim: z.boolean().optional(),\n  normalize: z.enum(['none', 'NFC', 'NFKC']).optional(),\n  foldDiacritics: z.boolean().optional(),\n  collapseInnerWhitespace: z.boolean().optional(),\n  ignorePunctuation: z.boolean().optional(),\n  levenshtein: z.number().int().min(0).optional(),\n  locale: z.string().optional(),\n});\n\n/**\n * Zod schema for a single fill-in-the-blank slot configuration. Loose:\n * unknown keys are preserved through validation. Accepted answers must\n * contain non-whitespace characters — a whitespace-only accepted answer\n * normalizes to the empty string and would mark an empty response correct.\n */\nexport const BlankConfigSchema = z.looseObject({\n  id: z.string().min(1),\n  acceptedAnswers: z\n    .array(\n      z\n        .string()\n        .min(1)\n        .refine((answer) => answer.trim().length > 0, {\n          error: 'Accepted answers must contain non-whitespace characters.',\n        }),\n    )\n    .min(1),\n  caseSensitive: z.boolean().optional(),\n  trimWhitespace: z.boolean().optional(),\n  match: TextMatchPolicySchema.optional(),\n  hint: z.string().optional(),\n  feedback: z.string().optional(),\n});\n\n/**\n * Zod schema validating the full Fill-in-the-Blanks activity data contract.\n * Loose at every level: unknown keys are preserved, never stripped (B7).\n *\n * The refinement enforces a true one-to-one correspondence between `{{id}}`\n * placeholders and `blanks[].id`: every blank id appears EXACTLY ONCE in the\n * passage and exactly once in `blanks[]`. (The previous set-based check let\n * duplicate placeholders and duplicate blank configs through, corrupting the\n * partial-score denominator and per-item details.)\n */\nexport const FillInTheBlanksDataSchema = z\n  .looseObject({\n    schemaVersion: z.literal('1.0'),\n    type: z.literal('fill-in-the-blanks'),\n    id: z.string().min(1),\n    title: z.string().min(1),\n    passage: z.string().min(1),\n    passageHtml: z.string().optional(),\n    blanks: z.array(BlankConfigSchema).min(1),\n    scoringStrategy: z.enum(['all-or-nothing', 'partial']),\n    media: MediaSchema.optional(),\n    feedback: FeedbackSchema.optional(),\n    passThreshold: z.number().min(0).max(1).optional(),\n    locale: z.string().optional(),\n    learningObjectives: z.array(z.string()).optional(),\n    difficultyLevel: z.literal([1, 2, 3, 4, 5]).optional(),\n  })\n  .refine(\n    (data) => {\n      const placeholderCounts = new Map<string, number>();\n      for (const match of data.passage.matchAll(PLACEHOLDER_RE)) {\n        const id = match[1] as string;\n        placeholderCounts.set(id, (placeholderCounts.get(id) ?? 0) + 1);\n      }\n      const blankIds = data.blanks.map((blank) => blank.id);\n      if (new Set(blankIds).size !== blankIds.length) {\n        return false;\n      }\n      if (placeholderCounts.size !== blankIds.length) {\n        return false;\n      }\n      return blankIds.every((id) => placeholderCounts.get(id) === 1);\n    },\n    {\n      error:\n        'Each blank id must appear exactly once in blanks[] and have exactly one matching {{id}} placeholder in the passage, and vice versa.',\n      path: ['passage'],\n    },\n  );\n","import { z } from 'zod/v4';\nimport { FeedbackSchema } from './feedback.js';\nimport { MediaSchema } from './media.js';\n\n/**\n * Zod schema for a single Multiple Choice option. Loose: unknown keys are\n * preserved through validation (forward-compat / consumer sidecars — B7).\n */\nexport const MultipleChoiceOptionSchema = z.looseObject({\n  id: z.string().min(1),\n  text: z.string().min(1),\n  isCorrect: z.boolean(),\n  feedback: z.string().optional(),\n});\n\n/**\n * Zod schema validating the full Multiple Choice activity data contract.\n * Loose at every level: unknown keys are preserved, never stripped, so a\n * v0.3 runtime reading a future payload (or a consumer sidecar field) does\n * not silently delete data.\n *\n * Semantic guards: (1) at least one option must be correct, otherwise the\n * activity can never be answered correctly; (2) `mode: 'single'` must have\n * exactly one correct option — multiple correct options under single-select\n * make `showCorrectAnswers` and the xAPI correct-response ambiguous and mask\n * authoring errors; (3) option ids must be unique — the scorer looks options\n * up by id, so a duplicate id makes one option unscoreable. All are\n * unrepresentable in JSON Schema and are dropped from `toJSONSchema` output\n * by design.\n */\nexport const MultipleChoiceDataSchema = z\n  .looseObject({\n    schemaVersion: z.literal('1.0'),\n    type: z.literal('multiple-choice'),\n    id: z.string().min(1),\n    title: z.string().min(1),\n    question: z.string().min(1),\n    questionHtml: z.string().optional(),\n    mode: z.enum(['single', 'multi']),\n    options: z.array(MultipleChoiceOptionSchema).min(2).max(26),\n    scoringStrategy: z.enum(['all-or-nothing', 'partial']),\n    media: MediaSchema.optional(),\n    feedback: FeedbackSchema.optional(),\n    passThreshold: z.number().min(0).max(1).optional(),\n    shuffle: z.boolean().optional(),\n    locale: z.string().optional(),\n    learningObjectives: z.array(z.string()).optional(),\n    difficultyLevel: z.literal([1, 2, 3, 4, 5]).optional(),\n  })\n  .refine((data) => data.options.some((option) => option.isCorrect), {\n    error: 'At least one option must be marked correct.',\n    path: ['options'],\n  })\n  .refine(\n    (data) =>\n      data.mode !== 'single' || data.options.filter((option) => option.isCorrect).length === 1,\n    {\n      error: 'Single-select activities (mode: \"single\") must have exactly one correct option.',\n      path: ['options'],\n    },\n  )\n  .refine((data) => new Set(data.options.map((option) => option.id)).size === data.options.length, {\n    error: 'Option ids must be unique within the activity.',\n    path: ['options'],\n  });\n","import { z } from 'zod/v4';\nimport { FeedbackSchema } from './feedback.js';\nimport { MediaSchema } from './media.js';\n\n/** Zod schema for a single rubric criterion. Loose: unknown keys preserved. */\nexport const WrittenResponseRubricCriterionSchema = z.looseObject({\n  name: z.string().min(1),\n  description: z.string().optional(),\n  weight: z.number().min(0),\n});\n\n/** Zod schema for a written-response grading rubric. Loose: unknown keys preserved. */\nexport const WrittenResponseRubricSchema = z.looseObject({\n  label: z.string().optional(),\n  criteria: z.array(WrittenResponseRubricCriterionSchema).min(1),\n});\n\n/**\n * Zod schema validating the Written Response activity data contract (Req 22).\n *\n * Wire-format constraints (Req 22.9): field names are locked for\n * byte-compatibility with consumer-stored rows, and the schema is loose at\n * EVERY level (Req 22.5) — unknown top-level keys, `promptHtml`, `rubric`\n * sidecars and any future fields survive `validateActivity` verbatim.\n */\nexport const WrittenResponseDataSchema = z\n  .looseObject({\n    schemaVersion: z.literal('1.0'),\n    type: z.literal('written-response'),\n    id: z.string().min(1),\n    title: z.string().min(1),\n    prompt: z.string(),\n    promptHtml: z.string().optional(),\n    minWords: z.number().int().min(0),\n    maxWords: z.number().int().min(1),\n    rubric: WrittenResponseRubricSchema.optional(),\n    languageTarget: z.string().optional(),\n    media: MediaSchema.optional(),\n    feedback: FeedbackSchema.optional(),\n    passThreshold: z.number().min(0).max(1).optional(),\n    locale: z.string().optional(),\n    learningObjectives: z.array(z.string()).optional(),\n    difficultyLevel: z.literal([1, 2, 3, 4, 5]).optional(),\n  })\n  .refine((data) => data.maxWords >= data.minWords, {\n    error: 'maxWords must be greater than or equal to minWords.',\n    path: ['maxWords'],\n  });\n","import { z } from 'zod/v4';\nimport { MediaSchema } from './media.js';\nimport { WrittenResponseRubricSchema } from './written-response.js';\n\n/**\n * Schemas for REDACTED activity data — the learner-safe projection `redact()`\n * produces (R7). Deliberately STRICT (`z.strictObject`), the opposite of the\n * loose content schemas: a redacted payload must prove the ABSENCE of every\n * answer-key and author-only field, so any unknown key is a validation\n * failure, not a passthrough. `assertRedacted` validates against these.\n */\n\n/** Shared fields every redacted activity carries. */\nconst redactedBase = {\n  /** Marker distinguishing a redacted projection from full activity data. */\n  redacted: z.literal(true),\n  /** Slot identity, carried through redaction so the client and the plan agree. */\n  slotKey: z.string().min(1).optional(),\n  schemaVersion: z.literal('1.0'),\n  id: z.string().min(1),\n  title: z.string().min(1),\n  media: MediaSchema.optional(),\n  passThreshold: z.number().min(0).max(1).optional(),\n  locale: z.string().optional(),\n  learningObjectives: z.array(z.string()).optional(),\n  difficultyLevel: z.literal([1, 2, 3, 4, 5]).optional(),\n};\n\n/** A redacted Multiple Choice option: id and display text only — no `isCorrect`, no feedback. */\nexport const RedactedMultipleChoiceOptionSchema = z.strictObject({\n  id: z.string().min(1),\n  text: z.string().min(1),\n});\n\n/**\n * Redacted Multiple Choice data: renderable (question, mode, options to pick\n * from) with the answer key, per-option feedback, overall feedback, and the\n * scoring strategy removed. `scoringStrategy` is answer-key by design: MC\n * `partial` carries a wrong-selection penalty `all-or-nothing` does not, so\n * knowing the strategy tells a learner whether guessing is free.\n */\nexport const RedactedMultipleChoiceDataSchema = z.strictObject({\n  ...redactedBase,\n  type: z.literal('multiple-choice'),\n  question: z.string().min(1),\n  questionHtml: z.string().optional(),\n  mode: z.enum(['single', 'multi']),\n  options: z.array(RedactedMultipleChoiceOptionSchema).min(2).max(26),\n  shuffle: z.boolean().optional(),\n});\n\n/** A redacted blank: id and hint only — no accepted answers, no matching rules, no feedback. */\nexport const RedactedBlankConfigSchema = z.strictObject({\n  id: z.string().min(1),\n  hint: z.string().optional(),\n});\n\n/** Redacted Fill-in-the-Blanks data: passage and blank slots, key removed. */\nexport const RedactedFillInTheBlanksDataSchema = z.strictObject({\n  ...redactedBase,\n  type: z.literal('fill-in-the-blanks'),\n  passage: z.string().min(1),\n  passageHtml: z.string().optional(),\n  blanks: z.array(RedactedBlankConfigSchema).min(1),\n});\n\n/**\n * Redacted Written Response data: the prompt, word bounds and rubric are\n * learner-visible (a rubric tells the learner what they are graded on);\n * authored pass/fail feedback is removed until the grade exists.\n */\nexport const RedactedWrittenResponseDataSchema = z.strictObject({\n  ...redactedBase,\n  type: z.literal('written-response'),\n  prompt: z.string(),\n  promptHtml: z.string().optional(),\n  minWords: z.number().int().min(0),\n  maxWords: z.number().int().min(1),\n  rubric: WrittenResponseRubricSchema.optional(),\n  languageTarget: z.string().optional(),\n});\n\n/**\n * The learner-safe SHAPE of each built-in type, derived from the strict schema\n * above rather than hand-written beside it.\n *\n * `redact()` returns {@link RedactedActivityData}, which proves a payload is\n * learner-safe but is index-signature typed — it deliberately says nothing\n * about what the payload still CONTAINS. That is right for the assertion and\n * useless for anything that has to render or transport the result, so every\n * integrator ends up re-declaring these interfaces by hand and they drift the\n * moment a schema changes. Deriving them with `z.infer` means the type and the\n * validator can never disagree.\n *\n * Use them for the payload a server sends an exam client, and for the props of\n * a renderer that must never see an answer key.\n */\nexport type RedactedMultipleChoiceOption = z.infer<typeof RedactedMultipleChoiceOptionSchema>;\n/** A Multiple Choice item with the answer key, feedback and strategy removed. */\nexport type RedactedMultipleChoiceData = z.infer<typeof RedactedMultipleChoiceDataSchema>;\n/** A blank with its accepted answers and matching rules removed; the hint survives. */\nexport type RedactedBlankConfig = z.infer<typeof RedactedBlankConfigSchema>;\n/** A Fill-in-the-Blanks item with every accepted answer removed. */\nexport type RedactedFillInTheBlanksData = z.infer<typeof RedactedFillInTheBlanksDataSchema>;\n/** A Written Response item; the rubric survives, because it tells the learner what is assessed. */\nexport type RedactedWrittenResponseData = z.infer<typeof RedactedWrittenResponseDataSchema>;\n\n/**\n * Discriminated union of every built-in redacted activity. Narrow it on\n * `type`, exactly as you would {@link ActivityData}:\n *\n * ```ts\n * function render(item: RedactedActivity) {\n *   if (item.type === 'multiple-choice') {\n *     return item.options.map((option) => option.text); // no `isCorrect` to leak\n *   }\n * }\n * ```\n */\nexport type RedactedActivity =\n  | RedactedMultipleChoiceData\n  | RedactedFillInTheBlanksData\n  | RedactedWrittenResponseData;\n","/**\n * Configurable free-text answer matching (R3.3).\n *\n * Grade-stability contract: the DEFAULTS reproduce the v1 fill-in-the-blanks\n * semantics exactly (trim, then locale-insensitive lowercase, strict `===`).\n * Every tolerance below is opt-in, because changing a default here changes\n * historical grades — and this SDK powers real summative exams.\n */\nexport interface TextMatchPolicy {\n  /** Compare case-sensitively. Default `false` (v1 behaviour). */\n  caseSensitive?: boolean;\n  /** Strip leading/trailing whitespace before comparing. Default `true` (v1 behaviour). */\n  trim?: boolean;\n  /**\n   * Unicode normalization applied to both sides before comparing. Default\n   * `'none'` (v1 behaviour). `'NFC'` makes a decomposed `está` (combining\n   * U+0301) equal its composed form — the fix for accent-input mismatches in\n   * EN/ES/PT content.\n   */\n  normalize?: 'none' | 'NFC' | 'NFKC';\n  /** Treat diacritics as equal to their base letters (`está` ≡ `esta`). Default `false`. */\n  foldDiacritics?: boolean;\n  /** Collapse runs of inner whitespace to a single space. Default `false`. */\n  collapseInnerWhitespace?: boolean;\n  /** Ignore Unicode punctuation on both sides. Default `false`. */\n  ignorePunctuation?: boolean;\n  /** Maximum Levenshtein edit distance still accepted as a match. Default `0`. */\n  levenshtein?: number;\n  /**\n   * BCP 47 tag for locale-aware case folding (e.g. `'tr'` for Turkish dotted /\n   * dotless I). Default: locale-insensitive `toLowerCase()` (v1 behaviour).\n   */\n  locale?: string;\n}\n\n/**\n * How a match was achieved. Lets a consumer award full credit for an `exact`\n * match and partial credit for a `folded` or `fuzzy` one (e.g. diacritic\n * tolerance in a listening gap-fill vs. a spelling test).\n * - `exact` — equal under the baseline trim/case rules alone.\n * - `normalized` — required Unicode normalization, whitespace collapse, or punctuation tolerance.\n * - `folded` — required diacritic folding.\n * - `fuzzy` — required Levenshtein tolerance.\n * - `none` — no accepted answer matched.\n */\nexport interface TextMatchResult {\n  matched: boolean;\n  via: 'exact' | 'normalized' | 'folded' | 'fuzzy' | 'none';\n}\n\n/** Combining marks (any script) removed for diacritic folding after NFD decomposition. */\nconst COMBINING_MARKS_RE = /\\p{M}/gu;\n/**\n * Unicode punctuation (`\\p{P}`) removed by `ignorePunctuation`. Deliberately\n * NOT `\\p{S}`: symbols like `$`, `+`, `%` can be the substance of an answer\n * (`$100` vs `100`), so a \"punctuation\" toggle must not erase them.\n */\nconst PUNCTUATION_RE = /\\p{P}/gu;\n\nfunction applyBaseline(value: string, policy: TextMatchPolicy): string {\n  let result = value;\n  if (policy.trim !== false) {\n    result = result.trim();\n  }\n  if (policy.caseSensitive !== true) {\n    result = policy.locale ? result.toLocaleLowerCase(policy.locale) : result.toLowerCase();\n  }\n  return result;\n}\n\nfunction applyNormalization(value: string, policy: TextMatchPolicy): string {\n  let result = value;\n  if (policy.normalize === 'NFC' || policy.normalize === 'NFKC') {\n    result = result.normalize(policy.normalize);\n  }\n  if (policy.ignorePunctuation === true) {\n    result = result.replace(PUNCTUATION_RE, '');\n  }\n  if (policy.collapseInnerWhitespace === true) {\n    // \"Inner\" means between non-space runs. Only trim the ends when the\n    // policy's trim is on (its default) — an explicit `trim: false` must not\n    // be silently overridden by the collapse.\n    result = result.replace(/(?<=\\S)\\s+(?=\\S)/g, ' ');\n    if (policy.trim !== false) {\n      result = result.trim();\n    }\n  }\n  return result;\n}\n\nfunction applyDiacriticFold(value: string): string {\n  return value.normalize('NFD').replace(COMBINING_MARKS_RE, '').normalize('NFC');\n}\n\n/**\n * Levenshtein distance with an early-exit bound: returns `max + 1` as soon as\n * the distance provably exceeds `max`.\n */\nexport function levenshteinDistance(a: string, b: string, max: number): number {\n  if (a === b) return 0;\n  if (Math.abs(a.length - b.length) > max) return max + 1;\n  if (a.length === 0) return b.length;\n  if (b.length === 0) return a.length;\n\n  let previous = Array.from({ length: b.length + 1 }, (_, i) => i);\n  for (let i = 1; i <= a.length; i += 1) {\n    const current = [i];\n    let rowMin = i;\n    for (let j = 1; j <= b.length; j += 1) {\n      const cost = a[i - 1] === b[j - 1] ? 0 : 1;\n      const value = Math.min(\n        (previous[j] as number) + 1,\n        (current[j - 1] as number) + 1,\n        (previous[j - 1] as number) + cost,\n      );\n      current.push(value);\n      if (value < rowMin) rowMin = value;\n    }\n    if (rowMin > max) return max + 1;\n    previous = current;\n  }\n  return previous[b.length] as number;\n}\n\n/**\n * Matches a learner's input against one or more accepted answers under a\n * {@link TextMatchPolicy}. Tolerances are evaluated in stages — baseline\n * (trim/case), then normalization, then diacritic folding, then Levenshtein —\n * and {@link TextMatchResult.via} reports the first stage that produced the\n * match, so graders can award credit by match quality.\n *\n * With no policy (or an empty one) this is byte-for-byte the v1 matching\n * semantics: `trim` + locale-insensitive `toLowerCase` + strict equality.\n */\nexport function matchText(\n  input: string,\n  accepted: string | readonly string[],\n  policy: TextMatchPolicy = {},\n): TextMatchResult {\n  const acceptedList = typeof accepted === 'string' ? [accepted] : accepted;\n  const baselineInput = applyBaseline(input, policy);\n  const baselineAccepted = acceptedList.map((answer) => applyBaseline(answer, policy));\n\n  if (baselineAccepted.some((answer) => answer === baselineInput)) {\n    return { matched: true, via: 'exact' };\n  }\n\n  const usesNormalization =\n    policy.normalize === 'NFC' ||\n    policy.normalize === 'NFKC' ||\n    policy.ignorePunctuation === true ||\n    policy.collapseInnerWhitespace === true;\n  const normalizedInput = usesNormalization\n    ? applyNormalization(baselineInput, policy)\n    : baselineInput;\n  const normalizedAccepted = usesNormalization\n    ? baselineAccepted.map((answer) => applyNormalization(answer, policy))\n    : baselineAccepted;\n\n  if (usesNormalization && normalizedAccepted.some((answer) => answer === normalizedInput)) {\n    return { matched: true, via: 'normalized' };\n  }\n\n  const foldedInput =\n    policy.foldDiacritics === true ? applyDiacriticFold(normalizedInput) : normalizedInput;\n  const foldedAccepted =\n    policy.foldDiacritics === true\n      ? normalizedAccepted.map((answer) => applyDiacriticFold(answer))\n      : normalizedAccepted;\n\n  if (policy.foldDiacritics === true && foldedAccepted.some((answer) => answer === foldedInput)) {\n    return { matched: true, via: 'folded' };\n  }\n\n  const maxDistance = policy.levenshtein ?? 0;\n  if (\n    maxDistance > 0 &&\n    foldedAccepted.some(\n      (answer) => levenshteinDistance(foldedInput, answer, maxDistance) <= maxDistance,\n    )\n  ) {\n    return { matched: true, via: 'fuzzy' };\n  }\n\n  return { matched: false, via: 'none' };\n}\n","import type { z } from 'zod/v4';\nimport type { DeferredScoringPartial, ScoringResult } from '../types/activity.js';\n\n/** ScoringResult without `passed` — the public `score()` / `evaluate()` fill that in. */\nexport type PartialScoringResult = Omit<ScoringResult, 'passed'>;\n\n/**\n * Sensitivity classification of a single activity-data field, driving\n * `redact()`:\n * - `public` — safe to send to a learner before they answer.\n * - `answer-key` — reveals (or helps infer) the correct answer or the scoring\n *   rules; removed unless `reveal: 'after-submit'` is requested.\n * - `author-only` — never leaves the authoring/grading context (e.g. rubrics).\n */\nexport type Sensitivity = 'public' | 'answer-key' | 'author-only';\n\n/**\n * Per-field sensitivity map for an activity type. A `Sensitivity` value\n * classifies the whole field (objects and arrays included); a nested\n * `FieldPolicy` recurses into an object field — and, for an array field,\n * applies to every element. Fail-closed: any field a policy does not mention\n * is treated as `author-only` and removed by `redact()` — adding a field\n * without classifying it hides it, never leaks it.\n */\nexport interface FieldPolicy {\n  readonly [field: string]: Sensitivity | FieldPolicy;\n}\n\n/** xAPI interaction types defined by xAPI 1.0.3 (cmi.interaction vocabulary). */\nexport type XAPIInteractionType =\n  | 'choice'\n  | 'fill-in'\n  | 'long-fill-in'\n  | 'matching'\n  | 'sequencing'\n  | 'performance'\n  | 'true-false'\n  | 'other';\n\n/** Interop facts a generic statement builder cannot infer from data alone. */\nexport interface ActivityTypeInterop<TData> {\n  /** IRI for the xAPI Activity `definition.type`. */\n  readonly xapiActivityTypeIri?: string;\n  /** xAPI `definition.interactionType` for this activity type. */\n  readonly xapiInteractionType?: XAPIInteractionType;\n  /** Builds the xAPI `correctResponsesPattern` strings for an item. */\n  readonly correctResponsesPattern?: (data: TData) => string[];\n}\n\n/**\n * How responses to an activity type are graded:\n * - `sync` — a pure function produces the grade at submit time.\n * - `deferred` — grading happens asynchronously (AI or human) after\n *   submission; `partial` reports the facts computable synchronously\n *   (e.g. word counts), surfaced in `ItemOutcome.partial`.\n */\nexport type ActivityTypeScoring<TData, TResponse> =\n  | {\n      readonly kind: 'sync';\n      readonly score: (data: TData, response: TResponse) => PartialScoringResult;\n    }\n  | {\n      readonly kind: 'deferred';\n      readonly reason: 'requires_async_grading';\n      readonly partial?: (data: TData, response: TResponse | undefined) => DeferredScoringPartial;\n    };\n\n/**\n * A value-level description of an activity type: its contract (schema), its\n * grading, its redaction policy, and its interop facts. Registering a\n * descriptor makes `validateActivity`, `score`, `evaluate`, `redact`, and\n * `jsonSchemaFor` work for the type — an activity type is a value, not a\n * hardcoded union member (R1).\n */\nexport interface ActivityTypeDescriptor<TData extends { type: string }, TResponse> {\n  /** The `type` discriminator string (kebab-case by convention). */\n  readonly type: TData['type'];\n  /** Zod schema validating the activity's data contract. */\n  readonly schema: z.ZodType<TData>;\n  /** How responses are graded. */\n  readonly scoring: ActivityTypeScoring<TData, TResponse>;\n  /** Whether a response counts as an answer (vs. blank/untouched). */\n  readonly isAnswered?: (response: TResponse | undefined) => boolean;\n  /** Per-field sensitivity map driving `redact()`. Fail-closed. */\n  readonly fieldPolicy?: FieldPolicy;\n  /**\n   * Schema the output of `redact(data)` (with default `reveal: 'none'`) must\n   * satisfy. Strict by design: it proves the ABSENCE of answer-key fields,\n   * so `assertRedacted` can guarantee a payload is safe to send to a learner.\n   */\n  readonly redactedSchema?: z.ZodType<unknown>;\n  /** Interop facts for xAPI (and later QTI) statement building. */\n  readonly interop?: ActivityTypeInterop<TData>;\n  /** The interaction-event kinds components for this type emit. */\n  readonly interactions?: readonly string[];\n}\n\n/**\n * Internal type-erased descriptor shape stored in the registry. Dispatch call\n * sites cast payloads back; the public generic API preserves inference.\n */\nexport interface RegisteredActivityTypeDescriptor {\n  readonly type: string;\n  readonly schema: z.ZodType<unknown>;\n  readonly scoring:\n    | {\n        readonly kind: 'sync';\n        readonly score: (data: unknown, response: unknown) => PartialScoringResult;\n      }\n    | {\n        readonly kind: 'deferred';\n        readonly reason: 'requires_async_grading';\n        readonly partial?: (data: unknown, response: unknown) => DeferredScoringPartial;\n      };\n  readonly isAnswered?: (response: unknown) => boolean;\n  readonly fieldPolicy?: FieldPolicy;\n  readonly redactedSchema?: z.ZodType<unknown>;\n  readonly interop?: ActivityTypeInterop<unknown>;\n  readonly interactions?: readonly string[];\n}\n\n/**\n * Module-scoped default registry (deliberate — no registry instances until a\n * second consumer exists; see roadmap §3.2 / audit §15.3).\n */\nconst registry = new Map<string, RegisteredActivityTypeDescriptor>();\n\n/**\n * Identity helper that gives full type inference when authoring a descriptor:\n *\n * ```ts\n * const myType = defineActivityType<MyTypeData, MyTypeLearnerResponse>({ ... });\n * registerActivityType(myType);\n * ```\n */\nexport function defineActivityType<TData extends { type: string }, TResponse>(\n  descriptor: ActivityTypeDescriptor<TData, TResponse>,\n): ActivityTypeDescriptor<TData, TResponse> {\n  return descriptor;\n}\n\n/**\n * Registers an activity type on the default registry, making it live for\n * `validateActivity`, `score`, `evaluate`, `redact`, and `jsonSchemaFor`.\n * Re-registering the same descriptor object is a no-op; registering a\n * DIFFERENT descriptor under an existing type throws — silently replacing a\n * type's contract or scoring is exactly the class of accident a summative\n * SDK must not allow.\n */\nexport function registerActivityType<TData extends { type: string }, TResponse>(\n  descriptor: ActivityTypeDescriptor<TData, TResponse>,\n): void {\n  if (descriptor.type === 'item-group') {\n    // The container that holds several items around one stimulus. It has no\n    // learner response and no score of its own, so it can never satisfy this\n    // contract — and letting a consumer register one would make `isItemGroup`\n    // and `flattenSequence` misread their own container.\n    throw new Error(\n      '\"item-group\" is reserved for the SDK\\'s item-group container (see ItemGroup) and cannot be registered as an activity type.',\n    );\n  }\n  const existing = registry.get(descriptor.type);\n  if (existing !== undefined) {\n    if ((existing as unknown) === (descriptor as unknown)) {\n      return;\n    }\n    throw new Error(\n      `Activity type \"${descriptor.type}\" is already registered. ` +\n        'Registering a different descriptor for an existing type is not allowed.',\n    );\n  }\n  registry.set(descriptor.type, descriptor as unknown as RegisteredActivityTypeDescriptor);\n}\n\n/** Returns the registered descriptor for `type`, or `undefined`. */\nexport function getActivityTypeDescriptor(\n  type: string,\n): RegisteredActivityTypeDescriptor | undefined {\n  return registry.get(type);\n}\n\n/** The type strings currently registered (built-ins plus consumer-registered). */\nexport function registeredActivityTypes(): string[] {\n  return [...registry.keys()];\n}\n","/**\n * All-or-nothing scoring: full credit only when every item is correct.\n *\n * @param correctItems - per-item correctness flags for the relevant items\n * @returns `1` if every item is correct (or the list is empty), otherwise `0`\n */\nexport function allOrNothingStrategy(correctItems: boolean[]): number {\n  return correctItems.every((isCorrect) => isCorrect) ? 1 : 0;\n}\n","/**\n * Partial-credit scoring for Multiple Choice — balanced/symmetric scheme.\n *\n * Reward and penalty are each normalised by their own pool: the fraction of\n * correct options found, minus the fraction of distractors wrongly chosen.\n * This is fairer than normalising the penalty by the correct-option count —\n * under that older form a single wrong pick could zero an otherwise-correct\n * response when there was only one correct answer.\n *\n * Result is always in [0, 1]: `reward ∈ [0,1]` and `penalty ∈ [0,1]`, so\n * `reward - penalty ∈ [-1,1]` and `max(0, …)` floors it at 0. Selecting every\n * option yields `1 - 1 = 0`; selecting exactly the correct set yields `1`.\n *\n * @param correctSelected - number of selected options that are correct\n * @param incorrectSelected - number of selected options that are incorrect\n * @param totalCorrect - total correct options; the `MultipleChoiceDataSchema`\n *   \"≥1 correct\" guard guarantees this is ≥ 1, so the reward term cannot\n *   divide by zero for schema-validated data\n * @param totalIncorrect - total incorrect options (distractors); when `0`\n *   (every option is correct) the penalty term is defined as `0`\n */\nexport function partialStrategy(\n  correctSelected: number,\n  incorrectSelected: number,\n  totalCorrect: number,\n  totalIncorrect: number,\n): number {\n  const reward = correctSelected / totalCorrect;\n  const penalty = totalIncorrect === 0 ? 0 : incorrectSelected / totalIncorrect;\n  return Math.max(0, reward - penalty);\n}\n\n/**\n * Partial-credit scoring for Fill-in-the-Blanks: fraction of blanks answered\n * correctly. Each blank is independently right or wrong, so a plain proportion\n * is already fair — no penalty term applies.\n *\n * @param correctBlanks - number of blanks answered correctly\n * @param totalBlanks - total number of blanks; the `FillInTheBlanksDataSchema`\n *   `blanks.min(1)` constraint guarantees this is ≥ 1, so division by zero\n *   cannot occur for schema-validated data\n */\nexport function partialBlankStrategy(correctBlanks: number, totalBlanks: number): number {\n  return correctBlanks / totalBlanks;\n}\n","import type {\n  BlankConfig,\n  FillInTheBlanksData,\n  FillInTheBlanksLearnerResponse,\n  ScoringDetail,\n} from '../../types/activity.js';\nimport { allOrNothingStrategy } from '../strategies/all-or-nothing.js';\nimport { partialBlankStrategy } from '../strategies/partial.js';\nimport { matchText, type TextMatchPolicy } from '../text-match.js';\nimport type { PartialScoringResult } from './multiple-choice.js';\n\n/**\n * Resolves the effective match policy for a blank. The legacy\n * `caseSensitive` / `trimWhitespace` flags map onto the baseline policy\n * fields; an explicit `blank.match` policy takes precedence field-by-field.\n * With neither present, the result is the v1 semantics exactly.\n */\nfunction policyFor(blank: BlankConfig): TextMatchPolicy {\n  return {\n    ...(blank.caseSensitive !== undefined ? { caseSensitive: blank.caseSensitive } : {}),\n    ...(blank.trimWhitespace !== undefined ? { trim: blank.trimWhitespace } : {}),\n    ...blank.match,\n  };\n}\n\n/**\n * Scores a Fill-in-the-Blanks response. Each blank is evaluated independently\n * via {@link matchText} under the blank's resolved policy; a missing answer\n * key is treated as empty input and scored incorrect.\n */\nexport function scoreFillInTheBlanks(\n  data: FillInTheBlanksData,\n  response: FillInTheBlanksLearnerResponse,\n): PartialScoringResult {\n  const details: ScoringDetail[] = [];\n  const perBlankCorrect: boolean[] = [];\n\n  for (const blank of data.blanks) {\n    const rawInput = response.answers[blank.id];\n    const input = typeof rawInput === 'string' ? rawInput : '';\n    const matched = matchText(input, blank.acceptedAnswers, policyFor(blank)).matched;\n\n    perBlankCorrect.push(matched);\n    details.push({\n      itemId: blank.id,\n      correct: matched,\n      outcome: matched ? 'correct' : 'incorrect',\n      learnerResponse: [input],\n      correctResponse: [...blank.acceptedAnswers],\n      weight: 1,\n    });\n  }\n\n  const correctBlanks = perBlankCorrect.filter(Boolean).length;\n  const scoreValue =\n    data.scoringStrategy === 'all-or-nothing'\n      ? allOrNothingStrategy(perBlankCorrect)\n      : partialBlankStrategy(correctBlanks, data.blanks.length);\n\n  return { score: scoreValue, maxScore: 1, feedback: null, details };\n}\n","import type { PartialScoringResult } from '../../registry/registry.js';\nimport type {\n  MultipleChoiceData,\n  MultipleChoiceLearnerResponse,\n  ScoringDetail,\n} from '../../types/activity.js';\nimport { partialStrategy } from '../strategies/partial.js';\n\nexport type { PartialScoringResult } from '../../registry/registry.js';\n\n/**\n * Scores a Multiple Choice response. Pure; trusts its typed inputs (validation\n * is the component boundary's job). Options are looked up by id; an unknown\n * selected id is treated as an incorrect selection.\n */\nexport function scoreMultipleChoice(\n  data: MultipleChoiceData,\n  response: MultipleChoiceLearnerResponse,\n): PartialScoringResult {\n  const optionById = new Map(data.options.map((option) => [option.id, option]));\n  const selected = new Set(response.selectedOptionIds);\n\n  const totalCorrect = data.options.filter((option) => option.isCorrect).length;\n  const totalIncorrect = data.options.length - totalCorrect;\n\n  let scoreValue: number;\n\n  if (data.scoringStrategy === 'all-or-nothing') {\n    if (data.mode === 'single') {\n      scoreValue =\n        response.selectedOptionIds.length === 1 &&\n        optionById.get(response.selectedOptionIds[0])?.isCorrect === true\n          ? 1\n          : 0;\n    } else {\n      const correctIds = data.options.filter((o) => o.isCorrect).map((o) => o.id);\n      const allCorrectSelected = correctIds.every((id) => selected.has(id));\n      scoreValue = selected.size === correctIds.length && allCorrectSelected ? 1 : 0;\n    }\n  } else {\n    let correctSelected = 0;\n    let incorrectSelected = 0;\n    for (const id of selected) {\n      const option = optionById.get(id);\n      if (option?.isCorrect) {\n        correctSelected += 1;\n      } else {\n        incorrectSelected += 1;\n      }\n    }\n    scoreValue = partialStrategy(correctSelected, incorrectSelected, totalCorrect, totalIncorrect);\n  }\n\n  const details: ScoringDetail[] = data.options.map((option) => {\n    const wasSelected = selected.has(option.id);\n    const outcome = wasSelected\n      ? option.isCorrect\n        ? 'correct'\n        : 'incorrect'\n      : option.isCorrect\n        ? 'incorrect-omission'\n        : 'correct-omission';\n    return {\n      itemId: option.id,\n      correct: wasSelected === option.isCorrect,\n      outcome,\n      learnerResponse: [wasSelected ? 'selected' : 'not-selected'],\n      correctResponse: [option.isCorrect ? 'selected' : 'not-selected'],\n      weight: 1,\n    };\n  });\n\n  return { score: scoreValue, maxScore: 1, feedback: null, details };\n}\n","import type { z } from 'zod/v4';\nimport { countWords } from '../count-words.js';\nimport { FillInTheBlanksDataSchema } from '../schemas/fill-in-the-blanks.js';\nimport { MultipleChoiceDataSchema } from '../schemas/multiple-choice.js';\nimport {\n  RedactedFillInTheBlanksDataSchema,\n  RedactedMultipleChoiceDataSchema,\n  RedactedWrittenResponseDataSchema,\n} from '../schemas/redacted.js';\nimport { WrittenResponseDataSchema } from '../schemas/written-response.js';\nimport { scoreFillInTheBlanks } from '../scoring/activity-scorers/fill-in-the-blanks.js';\nimport { scoreMultipleChoice } from '../scoring/activity-scorers/multiple-choice.js';\nimport type {\n  FillInTheBlanksData,\n  FillInTheBlanksLearnerResponse,\n  MultipleChoiceData,\n  MultipleChoiceLearnerResponse,\n  WrittenResponseData,\n  WrittenResponseLearnerResponse,\n} from '../types/activity.js';\nimport { defineActivityType, type FieldPolicy, registerActivityType } from './registry.js';\n\n/**\n * Field-sensitivity policies for the built-in types (R7). Fail-closed:\n * anything not listed here is dropped by `redact()`. `scoringStrategy` is\n * answer-key everywhere — MC `partial` penalises wrong selections while\n * `all-or-nothing` does not, so the strategy reveals whether guessing is\n * free. Authored feedback is answer-key (it may quote or hint the answer).\n * Rubrics are PUBLIC: a rubric tells the learner what they are assessed on,\n * and a deployment that wants it hidden tightens it per call — see the\n * `rubric` entry in the written-response policy below.\n */\nconst SHARED_PUBLIC_FIELDS: FieldPolicy = {\n  schemaVersion: 'public',\n  type: 'public',\n  id: 'public',\n  // Assembly metadata, not content: it names the slot this item occupies in a\n  // paper. It has to survive redaction, or the exam client derives positional\n  // slot ids while the server's stored plan holds keyed ones, and the\n  // responses cannot be matched back to the attempt.\n  slotKey: 'public',\n  title: 'public',\n  media: 'public',\n  passThreshold: 'public',\n  locale: 'public',\n  learningObjectives: 'public',\n  difficultyLevel: 'public',\n};\n\nconst MULTIPLE_CHOICE_FIELD_POLICY: FieldPolicy = {\n  ...SHARED_PUBLIC_FIELDS,\n  question: 'public',\n  questionHtml: 'public',\n  mode: 'public',\n  shuffle: 'public',\n  scoringStrategy: 'answer-key',\n  feedback: 'answer-key',\n  options: {\n    id: 'public',\n    text: 'public',\n    isCorrect: 'answer-key',\n    feedback: 'answer-key',\n  },\n};\n\nconst FILL_IN_THE_BLANKS_FIELD_POLICY: FieldPolicy = {\n  ...SHARED_PUBLIC_FIELDS,\n  passage: 'public',\n  passageHtml: 'public',\n  scoringStrategy: 'answer-key',\n  feedback: 'answer-key',\n  blanks: {\n    id: 'public',\n    hint: 'public',\n    acceptedAnswers: 'answer-key',\n    caseSensitive: 'answer-key',\n    trimWhitespace: 'answer-key',\n    match: 'answer-key',\n    feedback: 'answer-key',\n  },\n};\n\nconst WRITTEN_RESPONSE_FIELD_POLICY: FieldPolicy = {\n  ...SHARED_PUBLIC_FIELDS,\n  prompt: 'public',\n  promptHtml: 'public',\n  minWords: 'public',\n  maxWords: 'public',\n  languageTarget: 'public',\n  feedback: 'answer-key',\n  // A rubric is a LEARNER affordance, not a grader secret: it tells the\n  // learner what they are being graded on, which is pedagogically the point\n  // of publishing one. (Classifying it author-only broke real deployments\n  // that render a rubric panel during the attempt.) A deployment that wants\n  // it hidden can tighten this per call via `redact(data, { policy })`.\n  rubric: 'public',\n};\n\n/** Built-in Multiple Choice descriptor. */\nexport const multipleChoiceType = defineActivityType<\n  MultipleChoiceData,\n  MultipleChoiceLearnerResponse\n>({\n  type: 'multiple-choice',\n  // zod4 optional outputs are `T | undefined`; the hand-written wire types use\n  // exact optionals. Structurally identical at runtime — cast is type-level only.\n  schema: MultipleChoiceDataSchema as unknown as z.ZodType<MultipleChoiceData>,\n  scoring: { kind: 'sync', score: scoreMultipleChoice },\n  isAnswered: (response) => (response?.selectedOptionIds.length ?? 0) > 0,\n  fieldPolicy: MULTIPLE_CHOICE_FIELD_POLICY,\n  redactedSchema: RedactedMultipleChoiceDataSchema,\n  interop: {\n    xapiActivityTypeIri: 'http://adlnet.gov/expapi/activities/cmi.interaction',\n    xapiInteractionType: 'choice',\n    correctResponsesPattern: (data) => [\n      data.options\n        .filter((option) => option.isCorrect)\n        .map((option) => option.id)\n        .join('[,]'),\n    ],\n  },\n  interactions: ['option-selected', 'option-deselected', 'submitted'],\n});\n\n/** Built-in Fill-in-the-Blanks descriptor. */\nexport const fillInTheBlanksType = defineActivityType<\n  FillInTheBlanksData,\n  FillInTheBlanksLearnerResponse\n>({\n  type: 'fill-in-the-blanks',\n  schema: FillInTheBlanksDataSchema as unknown as z.ZodType<FillInTheBlanksData>,\n  scoring: { kind: 'sync', score: scoreFillInTheBlanks },\n  isAnswered: (response) =>\n    Object.values(response?.answers ?? {}).some((answer) => answer.trim().length > 0),\n  fieldPolicy: FILL_IN_THE_BLANKS_FIELD_POLICY,\n  redactedSchema: RedactedFillInTheBlanksDataSchema,\n  interop: {\n    xapiActivityTypeIri: 'http://adlnet.gov/expapi/activities/cmi.interaction',\n    xapiInteractionType: 'fill-in',\n    // xAPI fill-in pattern: blank answers joined with \"[,]\". Only the first\n    // accepted answer per blank is emitted (full alternates would explode\n    // combinatorially); the complete key lives in the activity data.\n    correctResponsesPattern: (data) => [\n      data.blanks.map((blank) => blank.acceptedAnswers[0] ?? '').join('[,]'),\n    ],\n  },\n  interactions: ['blank-filled', 'hint-requested', 'submitted'],\n});\n\n/**\n * Built-in Written Response descriptor. Grading is DEFERRED: submissions are\n * graded asynchronously (AI or human) by the consumer; the synchronous\n * outcome reports only word-count facts. `wordCount` is recomputed from the\n * submitted text with the canonical `countWords()` — the client-supplied\n * count is informational, never trusted.\n */\nexport const writtenResponseType = defineActivityType<\n  WrittenResponseData,\n  WrittenResponseLearnerResponse\n>({\n  type: 'written-response',\n  schema: WrittenResponseDataSchema as unknown as z.ZodType<WrittenResponseData>,\n  scoring: {\n    kind: 'deferred',\n    reason: 'requires_async_grading',\n    partial: (data, response) => {\n      const wordCount = countWords(response?.text ?? '');\n      return {\n        withinWordBounds:\n          response !== undefined && wordCount >= data.minWords && wordCount <= data.maxWords,\n        wordCount,\n      };\n    },\n  },\n  isAnswered: (response) => (response?.text.trim().length ?? 0) > 0,\n  fieldPolicy: WRITTEN_RESPONSE_FIELD_POLICY,\n  redactedSchema: RedactedWrittenResponseDataSchema,\n  interop: {\n    xapiActivityTypeIri: 'http://adlnet.gov/expapi/activities/cmi.interaction',\n    xapiInteractionType: 'long-fill-in',\n    correctResponsesPattern: () => [],\n  },\n  interactions: ['text-changed', 'submitted'],\n});\n\nregisterActivityType(multipleChoiceType);\nregisterActivityType(fillInTheBlanksType);\nregisterActivityType(writtenResponseType);\n"],"mappings":"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","names":["z","z","z","z","z","z","z","z","z"]}

package/dist/{index-BKyZrd94.d.cts → index-B_RLyeEj.d.ts}

@@ -1,4 +1,4 @@
-import { A as ActivityData, c as ActivityMedia, t as ValidationResult, e as ActivityType, a as ActivityDataMap } from './activity-wkzRemHx.cjs';
+import { A as ActivityData, c as ActivityMedia, t as ValidationResult, e as ActivityType, a as ActivityDataMap } from './activity-gelWNZ6V.js';
 import { z } from 'zod/v4';
 
 /** What a stimulus primarily is. Drives validation and layout, never scoring. */
@@ -56,9 +56,26 @@ interface ItemGroup<TItem = ActivityData> {
     type: 'item-group';
     id: string;
     title?: string;
+    /**
+     * Stable identity for this entry's slots, independent of where it sits in
+     * the array. See {@link SequenceSlot.slotId}: without one, inserting a
+     * question above this group re-maps every slot id beneath it, and stored
+     * grades quietly start naming different questions.
+     */
+    slotKey?: string;
     stimulus: Stimulus;
-    /** The items, in authored order. Non-empty; ids unique within the group; no nested groups. */
-    items: TItem[];
+    /**
+     * The items, in authored order. Non-empty; ids unique within the group; no
+     * nested groups.
+     *
+     * An item may declare its own `slotKey`, for the same reason an entry can:
+     * it pins the item's identity within the group (`"reading.q1"` rather than
+     * `"reading.0"`), so inserting a question into a published group does not
+     * re-map the ones after it.
+     */
+    items: (TItem & {
+        slotKey?: string;
+    })[];
     /**
      * `none` (default) keeps authored order; `within-group` shuffles the items
      * among themselves under the sequence seed. Either way the group stays one
@@ -66,8 +83,20 @@ interface ItemGroup<TItem = ActivityData> {
      */
     shuffle?: 'none' | 'within-group';
 }
-/** What a sequence is made of: loose activities and item groups, in authored order. */
-type SequenceEntry<TItem = ActivityData> = TItem | ItemGroup<TItem>;
+/**
+ * What a sequence is made of: loose activities and item groups, in authored
+ * order.
+ *
+ * A plain activity may carry `slotKey` here even though no activity SCHEMA
+ * declares one, because a slot key describes an item's PLACE in a paper, not
+ * its content — the same question keeps its own id in every paper it appears
+ * in. Putting it on the entry rather than on the activity is what lets it be
+ * authored without every activity type having to know about assessment
+ * assembly. See {@link SequenceSlot.slotId}.
+ */
+type SequenceEntry<TItem = ActivityData> = (TItem & {
+    slotKey?: string;
+}) | ItemGroup<TItem>;
 /** The group a presented slot belongs to. */
 interface SequenceSlotGroup {
     id: string;
@@ -82,10 +111,20 @@ interface SequenceSlotGroup {
 interface SequenceSlot<TItem = ActivityData> {
     /**
      * Identity of the slot within the sequence definition — unique, and stable
-     * under shuffling. Derived from the AUTHORED position (`"2"` for the third
+     * under shuffling. Feed it to `composeAssessmentScore` as `slotId`.
+     *
+     * By default it is derived from the AUTHORED position (`"2"` for the third
      * top-level entry; `"2.1"` for the second item of that entry when it is a
      * group), so the same activity can appear in two entries and still be two
-     * slots. Feed it to `composeAssessmentScore` as `slotId`.
+     * slots.
+     *
+     * **A positional id is only valid against one version of the entries
+     * array.** Insert a question at the top of a published paper and every id
+     * below it shifts: rows stored as `"3"` now name what used to be entry 2,
+     * and a re-grade or a review render pairs each response with the wrong
+     * question — silently, because the ids still look valid. For any content
+     * whose slot ids you persist, give the entries an explicit `slotKey`; it is
+     * used verbatim here and survives insertion, deletion and re-ordering.
      */
     slotId: string;
     /** 0-based PRESENTED position, after shuffling. */
@@ -212,7 +251,7 @@ declare const FillInTheBlanksDataSchema: z.ZodObject<{
     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>>;
+    difficultyLevel: z.ZodOptional<z.ZodLiteral<2 | 1 | 3 | 4 | 5>>;
 }, z.core.$loose>;
 
 /**
@@ -262,6 +301,7 @@ declare const ItemGroupSchema: z.ZodObject<{
     type: z.ZodLiteral<"item-group">;
     id: z.ZodString;
     title: z.ZodOptional<z.ZodString>;
+    slotKey: z.ZodOptional<z.ZodString>;
     stimulus: z.ZodObject<{
         id: z.ZodString;
         kind: z.ZodEnum<{
@@ -292,12 +332,15 @@ declare const ItemGroupSchema: z.ZodObject<{
     items: z.ZodArray<z.ZodObject<{
         type: z.ZodString;
         id: z.ZodString;
+        slotKey: z.ZodOptional<z.ZodString>;
     }, z.core.$loose>>;
     shuffle: z.ZodOptional<z.ZodEnum<{
         none: "none";
         "within-group": "within-group";
     }>>;
 }, z.core.$loose>;
+/** The learner-safe shape of a stimulus, derived from the strict schema below. */
+type RedactedStimulus = z.infer<typeof RedactedStimulusSchema>;
 /** Strict learner-safe stimulus: everything but the author-only `transcript`. */
 declare const RedactedStimulusSchema: z.ZodObject<{
     id: z.ZodString;
@@ -336,6 +379,7 @@ declare const RedactedItemGroupSchema: z.ZodObject<{
     type: z.ZodLiteral<"item-group">;
     id: z.ZodString;
     title: z.ZodOptional<z.ZodString>;
+    slotKey: z.ZodOptional<z.ZodString>;
     stimulus: z.ZodObject<{
         id: z.ZodString;
         kind: z.ZodEnum<{
@@ -527,7 +571,7 @@ declare const MultipleChoiceDataSchema: z.ZodObject<{
     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>>;
+    difficultyLevel: z.ZodOptional<z.ZodLiteral<2 | 1 | 3 | 4 | 5>>;
 }, z.core.$loose>;
 
 /** A redacted Multiple Choice option: id and display text only — no `isCorrect`, no feedback. */
@@ -557,6 +601,8 @@ declare const RedactedMultipleChoiceDataSchema: z.ZodObject<{
     shuffle: z.ZodOptional<z.ZodBoolean>;
     /** Marker distinguishing a redacted projection from full activity data. */
     redacted: z.ZodLiteral<true>;
+    /** Slot identity, carried through redaction so the client and the plan agree. */
+    slotKey: z.ZodOptional<z.ZodString>;
     schemaVersion: z.ZodLiteral<"1.0">;
     id: z.ZodString;
     title: z.ZodString;
@@ -574,7 +620,7 @@ declare const RedactedMultipleChoiceDataSchema: z.ZodObject<{
     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>>;
+    difficultyLevel: z.ZodOptional<z.ZodLiteral<2 | 1 | 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<{
@@ -592,6 +638,8 @@ declare const RedactedFillInTheBlanksDataSchema: z.ZodObject<{
     }, z.core.$strict>>;
     /** Marker distinguishing a redacted projection from full activity data. */
     redacted: z.ZodLiteral<true>;
+    /** Slot identity, carried through redaction so the client and the plan agree. */
+    slotKey: z.ZodOptional<z.ZodString>;
     schemaVersion: z.ZodLiteral<"1.0">;
     id: z.ZodString;
     title: z.ZodString;
@@ -609,7 +657,7 @@ declare const RedactedFillInTheBlanksDataSchema: z.ZodObject<{
     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>>;
+    difficultyLevel: z.ZodOptional<z.ZodLiteral<2 | 1 | 3 | 4 | 5>>;
 }, z.core.$strict>;
 /**
  * Redacted Written Response data: the prompt, word bounds and rubric are
@@ -633,6 +681,8 @@ declare const RedactedWrittenResponseDataSchema: z.ZodObject<{
     languageTarget: z.ZodOptional<z.ZodString>;
     /** Marker distinguishing a redacted projection from full activity data. */
     redacted: z.ZodLiteral<true>;
+    /** Slot identity, carried through redaction so the client and the plan agree. */
+    slotKey: z.ZodOptional<z.ZodString>;
     schemaVersion: z.ZodLiteral<"1.0">;
     id: z.ZodString;
     title: z.ZodString;
@@ -650,8 +700,45 @@ declare const RedactedWrittenResponseDataSchema: z.ZodObject<{
     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>>;
+    difficultyLevel: z.ZodOptional<z.ZodLiteral<2 | 1 | 3 | 4 | 5>>;
 }, z.core.$strict>;
+/**
+ * The learner-safe SHAPE of each built-in type, derived from the strict schema
+ * above rather than hand-written beside it.
+ *
+ * `redact()` returns {@link RedactedActivityData}, which proves a payload is
+ * learner-safe but is index-signature typed — it deliberately says nothing
+ * about what the payload still CONTAINS. That is right for the assertion and
+ * useless for anything that has to render or transport the result, so every
+ * integrator ends up re-declaring these interfaces by hand and they drift the
+ * moment a schema changes. Deriving them with `z.infer` means the type and the
+ * validator can never disagree.
+ *
+ * Use them for the payload a server sends an exam client, and for the props of
+ * a renderer that must never see an answer key.
+ */
+type RedactedMultipleChoiceOption = z.infer<typeof RedactedMultipleChoiceOptionSchema>;
+/** A Multiple Choice item with the answer key, feedback and strategy removed. */
+type RedactedMultipleChoiceData = z.infer<typeof RedactedMultipleChoiceDataSchema>;
+/** A blank with its accepted answers and matching rules removed; the hint survives. */
+type RedactedBlankConfig = z.infer<typeof RedactedBlankConfigSchema>;
+/** A Fill-in-the-Blanks item with every accepted answer removed. */
+type RedactedFillInTheBlanksData = z.infer<typeof RedactedFillInTheBlanksDataSchema>;
+/** A Written Response item; the rubric survives, because it tells the learner what is assessed. */
+type RedactedWrittenResponseData = z.infer<typeof RedactedWrittenResponseDataSchema>;
+/**
+ * Discriminated union of every built-in redacted activity. Narrow it on
+ * `type`, exactly as you would {@link ActivityData}:
+ *
+ * ```ts
+ * function render(item: RedactedActivity) {
+ *   if (item.type === 'multiple-choice') {
+ *     return item.options.map((option) => option.text); // no `isCorrect` to leak
+ *   }
+ * }
+ * ```
+ */
+type RedactedActivity = RedactedMultipleChoiceData | RedactedFillInTheBlanksData | RedactedWrittenResponseData;
 
 /** Zod schema for a single rubric criterion. Loose: unknown keys preserved. */
 declare const WrittenResponseRubricCriterionSchema: z.ZodObject<{
@@ -712,7 +799,7 @@ declare const WrittenResponseDataSchema: z.ZodObject<{
     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>>;
+    difficultyLevel: z.ZodOptional<z.ZodLiteral<2 | 1 | 3 | 4 | 5>>;
 }, z.core.$loose>;
 
 /**
@@ -729,4 +816,4 @@ declare const WrittenResponseDataSchema: z.ZodObject<{
  */
 declare function validateActivity<T extends ActivityType>(type: T, data: unknown): ValidationResult<ActivityDataMap[T]>;
 
-export { BlankConfigSchema as B, FeedbackSchema as F, type ItemGroup as I, MediaSchema as M, RedactedBlankConfigSchema as R, type SequenceEntry as S, TextMatchPolicySchema as T, WrittenResponseDataSchema as W, FillInTheBlanksDataSchema as a, ItemGroupSchema as b, MediaUrlSchema as c, MultipleChoiceDataSchema as d, MultipleChoiceOptionSchema as e, RedactedFillInTheBlanksDataSchema as f, RedactedItemGroupSchema as g, RedactedMultipleChoiceDataSchema as h, RedactedMultipleChoiceOptionSchema as i, RedactedStimulusSchema as j, RedactedWrittenResponseDataSchema as k, type SequenceSlot as l, type SequenceSlotGroup as m, type Stimulus as n, type StimulusKind as o, StimulusSchema as p, WrittenResponseRubricCriterionSchema as q, WrittenResponseRubricSchema as r, fillInTheBlanksJsonSchema as s, itemGroupJsonSchema as t, jsonSchemaFor as u, multipleChoiceJsonSchema as v, stimulusJsonSchema as w, validateActivity as x, validateItemGroup as y, writtenResponseJsonSchema as z };
+export { itemGroupJsonSchema as A, BlankConfigSchema as B, jsonSchemaFor as C, multipleChoiceJsonSchema as D, stimulusJsonSchema as E, FeedbackSchema as F, validateActivity as G, validateItemGroup as H, type ItemGroup as I, writtenResponseJsonSchema as J, MediaSchema as M, type RedactedActivity as R, type SequenceEntry as S, TextMatchPolicySchema as T, WrittenResponseDataSchema as W, FillInTheBlanksDataSchema as a, ItemGroupSchema as b, MediaUrlSchema as c, MultipleChoiceDataSchema as d, MultipleChoiceOptionSchema as e, type RedactedBlankConfig as f, RedactedBlankConfigSchema as g, type RedactedFillInTheBlanksData as h, RedactedFillInTheBlanksDataSchema as i, RedactedItemGroupSchema as j, type RedactedMultipleChoiceData as k, RedactedMultipleChoiceDataSchema as l, type RedactedMultipleChoiceOption as m, RedactedMultipleChoiceOptionSchema as n, type RedactedStimulus as o, RedactedStimulusSchema as p, type RedactedWrittenResponseData as q, RedactedWrittenResponseDataSchema as r, type SequenceSlot as s, type SequenceSlotGroup as t, type Stimulus as u, type StimulusKind as v, StimulusSchema as w, WrittenResponseRubricCriterionSchema as x, WrittenResponseRubricSchema as y, fillInTheBlanksJsonSchema as z };