@longsightgroup/qti3-core 0.10.3 → 0.10.5

package/src/qti-package-zip.ts

@@ -7,17 +7,40 @@ export interface QtiPackageInflateContext {
   readonly compressedSize: number;
   readonly uncompressedSize: number;
   readonly compressionMethod: number;
+  /** Maximum output bytes the inflater may materialize for this entry. */
+  readonly maxOutputLength: number;
 }
 
-/** Optional raw DEFLATE inflater for ZIP entries compressed with method 8. */
+/**
+ * Optional raw DEFLATE inflater for ZIP entries compressed with method 8.
+ * Implementations must enforce `context.maxOutputLength` while expanding input.
+ */
 export type QtiPackageInflateRaw = (
   bytes: Uint8Array,
   context: QtiPackageInflateContext,
 ) => Uint8Array;
 
+/** Resource budgets applied before and after QTI package entry expansion. */
+export interface QtiPackageResourceLimits {
+  readonly maxEntries: number;
+  readonly maxEntryUncompressedBytes: number;
+  readonly maxTotalUncompressedBytes: number;
+  readonly maxCompressionRatio: number;
+}
+
+/** Conservative default budgets for untrusted QTI package ZIP input. */
+export const DEFAULT_QTI_PACKAGE_RESOURCE_LIMITS: QtiPackageResourceLimits = Object.freeze({
+  maxEntries: 4_096,
+  maxEntryUncompressedBytes: 128 * 1_024 * 1_024,
+  maxTotalUncompressedBytes: 512 * 1_024 * 1_024,
+  maxCompressionRatio: 200,
+});
+
 /** Options for parsing a QTI ZIP package. */
 export interface QtiPackageParseOptions {
   readonly inflateRaw?: QtiPackageInflateRaw | undefined;
+  /** Overrides for the default package resource budgets. */
+  readonly limits?: Partial<QtiPackageResourceLimits> | undefined;
 }
 
 /** Decoded ZIP entry from a QTI package. */
@@ -88,8 +111,19 @@ function readZipEntriesUnsafe(
     return [];
   }
 
+  const limits = resolveResourceLimits(options.limits);
   const entryCount = view.getUint16(eocdOffset + 10, true);
+  if (entryCount > limits.maxEntries) {
+    pushPackageDiagnostic(
+      diagnostics,
+      "package.zip.limit.entries",
+      "error",
+      `QTI package ZIP contains ${entryCount} entries; the configured limit is ${limits.maxEntries}.`,
+    );
+    return [];
+  }
   let offset = view.getUint32(eocdOffset + 16, true);
+  let totalUncompressedBytes = 0;
   const entries: QtiPackageEntry[] = [];
 
   for (let index = 0; index < entryCount; index += 1) {
@@ -116,6 +150,8 @@ function readZipEntriesUnsafe(
     const compressionMethod = view.getUint16(offset + 10, true);
     const compressedSize = view.getUint32(offset + 20, true);
     const uncompressedSize = view.getUint32(offset + 24, true);
+    const declaredExpandedSize =
+      compressionMethod === 0 ? Math.max(compressedSize, uncompressedSize) : uncompressedSize;
     const nameLength = view.getUint16(offset + 28, true);
     const extraLength = view.getUint16(offset + 30, true);
     const commentLength = view.getUint16(offset + 32, true);
@@ -137,6 +173,37 @@ function readZipEntriesUnsafe(
     offset += 46 + nameLength + extraLength + commentLength;
     if (decodedName.endsWith("/")) continue;
 
+    if (declaredExpandedSize > limits.maxEntryUncompressedBytes) {
+      pushPackageDiagnostic(
+        diagnostics,
+        "package.zip.limit.entrySize",
+        "error",
+        `ZIP entry ${decodedName} declares ${declaredExpandedSize} expanded bytes; the configured per-entry limit is ${limits.maxEntryUncompressedBytes}.`,
+        decodedName,
+      );
+      continue;
+    }
+    if (exceedsCompressionRatio(compressionMethod, compressedSize, uncompressedSize, limits)) {
+      pushPackageDiagnostic(
+        diagnostics,
+        "package.zip.limit.compressionRatio",
+        "error",
+        `ZIP entry ${decodedName} exceeds the configured compression ratio limit of ${limits.maxCompressionRatio}.`,
+        decodedName,
+      );
+      continue;
+    }
+    if (totalUncompressedBytes + declaredExpandedSize > limits.maxTotalUncompressedBytes) {
+      pushPackageDiagnostic(
+        diagnostics,
+        "package.zip.limit.totalSize",
+        "error",
+        `QTI package ZIP exceeds the configured total uncompressed size limit of ${limits.maxTotalUncompressedBytes} bytes.`,
+      );
+      break;
+    }
+    totalUncompressedBytes += declaredExpandedSize;
+
     const path = normalizePackagePath(decodedName, "ZIP entry", diagnostics);
     if (!path) continue;
 
@@ -151,6 +218,7 @@ function readZipEntriesUnsafe(
         localHeaderOffset,
       },
       options,
+      limits,
       diagnostics,
     );
     if (content) entries.push({ path, bytes: content });
@@ -170,6 +238,7 @@ function zipEntryBytes(
     readonly localHeaderOffset: number;
   },
   options: QtiPackageParseOptions,
+  limits: QtiPackageResourceLimits,
   diagnostics: QtiDiagnostic[],
 ): Uint8Array | undefined {
   if (entry.localHeaderOffset + 30 > view.byteLength) {
@@ -210,7 +279,9 @@ function zipEntryBytes(
   }
 
   const compressed = bytes.slice(dataOffset, dataEnd);
-  if (entry.compressionMethod === 0) return compressed;
+  if (entry.compressionMethod === 0) {
+    return validateExpandedSize(compressed, entry, limits, diagnostics);
+  }
 
   if (entry.compressionMethod === 8) {
     const inflateRaw = options.inflateRaw;
@@ -226,12 +297,14 @@ function zipEntryBytes(
     }
 
     try {
-      return inflateRaw(compressed, {
+      const expanded = inflateRaw(compressed, {
         path: entry.path,
         compressedSize: entry.compressedSize,
         uncompressedSize: entry.uncompressedSize,
         compressionMethod: entry.compressionMethod,
+        maxOutputLength: Math.max(1, entry.uncompressedSize),
       });
+      return validateExpandedSize(expanded, entry, limits, diagnostics);
     } catch {
       pushPackageDiagnostic(
         diagnostics,
@@ -254,6 +327,58 @@ function zipEntryBytes(
   return undefined;
 }
 
+function resolveResourceLimits(
+  overrides: QtiPackageParseOptions["limits"],
+): QtiPackageResourceLimits {
+  return {
+    maxEntries: overrides?.maxEntries ?? DEFAULT_QTI_PACKAGE_RESOURCE_LIMITS.maxEntries,
+    maxEntryUncompressedBytes:
+      overrides?.maxEntryUncompressedBytes ??
+      DEFAULT_QTI_PACKAGE_RESOURCE_LIMITS.maxEntryUncompressedBytes,
+    maxTotalUncompressedBytes:
+      overrides?.maxTotalUncompressedBytes ??
+      DEFAULT_QTI_PACKAGE_RESOURCE_LIMITS.maxTotalUncompressedBytes,
+    maxCompressionRatio:
+      overrides?.maxCompressionRatio ?? DEFAULT_QTI_PACKAGE_RESOURCE_LIMITS.maxCompressionRatio,
+  };
+}
+
+function exceedsCompressionRatio(
+  compressionMethod: number,
+  compressedSize: number,
+  uncompressedSize: number,
+  limits: QtiPackageResourceLimits,
+): boolean {
+  if (compressionMethod !== 8 || uncompressedSize === 0) return false;
+  if (compressedSize === 0) return true;
+  return uncompressedSize / compressedSize > limits.maxCompressionRatio;
+}
+
+function validateExpandedSize(
+  expanded: Uint8Array,
+  entry: {
+    readonly path: string;
+    readonly uncompressedSize: number;
+  },
+  limits: QtiPackageResourceLimits,
+  diagnostics: QtiDiagnostic[],
+): Uint8Array | undefined {
+  if (
+    expanded.length === entry.uncompressedSize &&
+    expanded.length <= limits.maxEntryUncompressedBytes
+  ) {
+    return expanded;
+  }
+  pushPackageDiagnostic(
+    diagnostics,
+    "package.zip.entry.size",
+    "error",
+    `ZIP entry ${entry.path} expanded to ${expanded.length} bytes; expected ${entry.uncompressedSize}.`,
+    entry.path,
+  );
+  return undefined;
+}
+
 function findEndOfCentralDirectory(view: DataView): number {
   const minimumOffset = Math.max(0, view.byteLength - 65557);
   for (let offset = view.byteLength - 22; offset >= minimumOffset; offset -= 1) {

package/src/qti-package.ts

@@ -1,29 +1,15 @@
 import { pushPackageDiagnostic } from "./qti-package-paths.js";
-import { collectPackageAssets } from "./qti-package-assets.js";
-import {
-  detectPackageShape,
-  diagnoseManifestDependencyReferences,
-  diagnosePrimaryResourceHrefs,
-  indexManifestResources,
-  isQtiAssessmentTestResource,
-  isQtiItemResource,
-  parseManifestResources,
-  QTI_PACKAGE_MANIFEST_PATH,
-} from "./qti-package-manifest.js";
+import { QTI_PACKAGE_MANIFEST_PATH } from "./qti-package-manifest.js";
+import { buildPackageSummary, inspectPackageManifest } from "./qti-package-plan.js";
 import {
   itemReferencesForPackageShape,
   parseAssessmentTestPackageModel,
   parsePackageItems,
 } from "./qti-package-items.js";
-import {
-  packageTitle,
-  parseStandardAlignments,
-  primaryTiming,
-  uniqueStandards,
-} from "./qti-package-metadata.js";
 import type { QtiPackageParseResult } from "./qti-package-types.js";
-import { parseXmlFiles, pushXmlDiagnostics } from "./qti-package-xml.js";
+import { parseXmlFiles } from "./qti-package-xml.js";
 import {
+  DEFAULT_QTI_PACKAGE_RESOURCE_LIMITS,
   decodeUtf8,
   readQtiPackageZipEntries,
   type QtiPackageEntry,
@@ -31,7 +17,7 @@ import {
 } from "./qti-package-zip.js";
 import type { QtiDiagnostic } from "./types.js";
 
-export { decodeUtf8, readQtiPackageZipEntries };
+export { DEFAULT_QTI_PACKAGE_RESOURCE_LIMITS, decodeUtf8, readQtiPackageZipEntries };
 export { discoverQtiPackageContentAssets } from "./qti-package-assets.js";
 export { normalizePackagePath } from "./qti-package-paths.js";
 export { QTI_ITEM_RESOURCE_TYPE, QTI_PACKAGE_MANIFEST_PATH } from "./qti-package-manifest.js";
@@ -63,6 +49,7 @@ export type {
   QtiPackageInflateContext,
   QtiPackageInflateRaw,
   QtiPackageParseOptions,
+  QtiPackageResourceLimits,
 } from "./qti-package-zip.js";
 
 /** Parse a QTI ZIP package into a neutral manifest, item, asset, and diagnostic model. */
@@ -82,47 +69,18 @@ function parseQtiPackageEntries(
 ): QtiPackageParseResult {
   const entriesByPath = indexEntries(entries, diagnostics);
   const xmlFilesByPath = parseXmlFiles(entriesByPath);
-  const manifestXml = xmlFilesByPath.get(QTI_PACKAGE_MANIFEST_PATH);
-
-  if (!manifestXml) {
-    pushPackageDiagnostic(
-      diagnostics,
-      "package.manifest.missing",
-      "error",
-      "QTI package does not contain imsmanifest.xml.",
-      QTI_PACKAGE_MANIFEST_PATH,
-    );
-  } else {
-    pushXmlDiagnostics(manifestXml, diagnostics);
-  }
-
-  const manifestRoot = manifestXml?.root?.localName === "manifest" ? manifestXml.root : undefined;
-  if (manifestXml?.root && !manifestRoot) {
-    pushPackageDiagnostic(
-      diagnostics,
-      "package.manifest.root",
-      "error",
-      `Expected imsmanifest.xml root manifest, found ${manifestXml.root.localName}.`,
-      QTI_PACKAGE_MANIFEST_PATH,
-    );
-  }
-
-  const manifestResourceRecords = manifestRoot
-    ? parseManifestResources(manifestRoot, entriesByPath, diagnostics)
-    : [];
-  const manifestResources = manifestResourceRecords;
-  const resourcesByIdentifier = indexManifestResources(manifestResourceRecords, diagnostics);
-  diagnoseManifestDependencyReferences(manifestResourceRecords, resourcesByIdentifier, diagnostics);
-
-  const itemResources = manifestResourceRecords.filter((resource) =>
-    isQtiItemResource(resource.type),
-  );
-  const assessmentTestResources = manifestResourceRecords.filter((resource) =>
-    isQtiAssessmentTestResource(resource.type),
+  const {
+    manifestRoot,
+    manifestResources,
+    resourcesByIdentifier,
+    itemResources,
+    assessmentTestResources,
+    packageShape,
+  } = inspectPackageManifest(
+    entriesByPath,
+    xmlFilesByPath.get(QTI_PACKAGE_MANIFEST_PATH),
+    diagnostics,
   );
-  diagnosePrimaryResourceHrefs([...itemResources, ...assessmentTestResources], diagnostics);
-
-  const packageShape = detectPackageShape(itemResources, assessmentTestResources, diagnostics);
   const assessmentTest = parseAssessmentTestPackageModel(
     packageShape,
     assessmentTestResources,
@@ -137,36 +95,27 @@ function parseQtiPackageEntries(
     diagnostics,
   );
   const items = parsePackageItems(itemReferences, entriesByPath, xmlFilesByPath, diagnostics);
-  const assets = collectPackageAssets(
+  const timedItems = items.filter((item) => item.timing !== undefined);
+  const { itemCount: _itemCount, ...summary } = buildPackageSummary({
+    manifestRoot,
+    manifestResources,
     resourcesByIdentifier,
+    packageShape,
     assessmentTest,
-    items,
+    assetItems: items,
+    titleItems: items,
+    timedItemCount: timedItems.length,
+    soleItemTiming: timedItems.length === 1 ? timedItems[0]?.timing : undefined,
+    itemStandards: items.flatMap((item) => item.standards),
     entriesByPath,
     diagnostics,
-  );
-  const manifestStandards = manifestRoot
-    ? parseStandardAlignments(manifestRoot, QTI_PACKAGE_MANIFEST_PATH)
-    : [];
-  const standards = uniqueStandards([
-    ...manifestStandards,
-    ...(assessmentTest?.standards ?? []),
-    ...items.flatMap((item) => item.standards),
-  ]);
-  const timing = primaryTiming(assessmentTest, items);
-  const title = packageTitle(manifestRoot, assessmentTest, items);
+    itemCount: items.length,
+  });
 
   return {
-    ok: diagnostics.every((diagnostic) => diagnostic.severity !== "error"),
-    title,
+    ...summary,
     entries,
-    packageShape,
     items,
-    assets,
-    manifestResources,
-    assessmentTest,
-    timing,
-    standards,
-    diagnostics,
   };
 }
 

package/src/response-validation.ts

@@ -1,13 +1,15 @@
 import type {
   QtiAssessmentItem,
+  QtiBaseType,
   QtiCardinality,
   QtiDiagnostic,
   QtiInteraction,
   QtiResponseDeclaration,
+  QtiScalarValue,
   QtiValue,
 } from "./types.js";
 import { assertNever } from "./assert-never.js";
-import { isNullResponse, isRecordValue } from "./processing-values.js";
+import { isNullResponse, isRecordValue, valueContainer } from "./processing-values.js";
 import { listNamedResponseInputs, type QtiNamedResponseInput } from "./response-input.js";
 import {
   matchMaxDiagnostics,
@@ -20,7 +22,9 @@ import {
   responseLimitAttribute,
   responseValidationPolicy,
 } from "./response-validation-policy.js";
-import { readQtiJsonValue } from "./value-format.js";
+import { parseQtiSliderDefinition, parseQtiSliderValue } from "./slider-definition.js";
+import { qtiValueToString, readQtiJsonValue } from "./value-format.js";
+import { parseQtiScalarForBaseType } from "./validation-primitives.js";
 
 export type { QtiNamedResponseInput as QtiResponseVariableInput } from "./response-input.js";
 export type QtiResponseVariablesInput = Record<string, unknown> | readonly QtiNamedResponseInput[];
@@ -30,6 +34,8 @@ export type QtiResponseValidationDiagnosticCode =
   | "response.maximum"
   | "response.matchMax"
   | "response.cardinality"
+  | "response.baseType"
+  | "response.domain"
   | "response.undeclared"
   | "response.identifier.required"
   | "response.value.invalid";
@@ -44,6 +50,17 @@ export interface QtiResponseValidationResult {
   diagnostics: QtiResponseValidationDiagnostic[];
 }
 
+type QtiResponseVariablesParseResult =
+  | {
+      ok: true;
+      diagnostics: QtiResponseValidationDiagnostic[];
+      responses: Record<string, QtiValue>;
+    }
+  | {
+      ok: false;
+      diagnostics: QtiResponseValidationDiagnostic[];
+    };
+
 export interface QtiResponseValidationInput {
   item: QtiAssessmentItem;
   responses: QtiResponseVariablesInput;
@@ -56,6 +73,14 @@ export interface QtiResponseValidationInput {
 export function validateQtiResponseVariables(
   input: QtiResponseValidationInput,
 ): QtiResponseValidationResult {
+  const result = parseQtiResponseVariables(input);
+  return { ok: result.ok, diagnostics: result.diagnostics };
+}
+
+/** Parse and normalize submitted response variables for trusted boundary application. */
+export function parseQtiResponseVariables(
+  input: QtiResponseValidationInput,
+): QtiResponseVariablesParseResult {
   const diagnostics: QtiResponseValidationDiagnostic[] = [];
   const declaredIdentifiers = new Set(
     input.item.responseDeclarations.map((declaration) => declaration.identifier),
@@ -81,11 +106,16 @@ export function validateQtiResponseVariables(
     }
 
     const value = responses.get(declaration.identifier);
+    const interactions = interactionsByResponse.get(declaration.identifier);
     if (value !== undefined) {
-      validateResponseCardinality(declaration, value, diagnostics);
+      const cardinalityMatches = validateResponseCardinality(declaration, value, diagnostics);
+      const parsedValue = parseResponseBaseType(declaration, value, diagnostics);
+      if (cardinalityMatches && parsedValue !== undefined) {
+        responses.set(declaration.identifier, parsedValue);
+        validateResponseDomain(declaration, interactions ?? [], parsedValue, diagnostics);
+      }
     }
 
-    const interactions = interactionsByResponse.get(declaration.identifier);
     if (interactions === undefined) {
       validateDeclarationResponse(
         declaration,
@@ -108,10 +138,10 @@ export function validateQtiResponseVariables(
     }
   }
 
-  return {
-    ok: diagnostics.every((diagnostic) => diagnostic.severity !== "error"),
-    diagnostics,
-  };
+  if (diagnostics.some((diagnostic) => diagnostic.severity === "error")) {
+    return { ok: false, diagnostics };
+  }
+  return { ok: true, diagnostics, responses: Object.fromEntries(responses) };
 }
 
 function ingestSubmittedResponses(
@@ -146,15 +176,16 @@ function ingestSubmittedResponses(
     }
 
     if (!declaredIdentifiers.has(identifier)) {
-      if (allowedUndeclaredIdentifiers.has(identifier)) continue;
-      diagnostics.push({
-        code: "response.undeclared",
-        severity: "error",
-        identifier,
-        message: `Response ${identifier} is not declared by the assessment item.`,
-        path: identifier,
-      });
-      continue;
+      if (!allowedUndeclaredIdentifiers.has(identifier)) {
+        diagnostics.push({
+          code: "response.undeclared",
+          severity: "error",
+          identifier,
+          message: `Response ${identifier} is not declared by the assessment item.`,
+          path: identifier,
+        });
+        continue;
+      }
     }
 
     responses.set(identifier, value);
@@ -184,10 +215,10 @@ function validateResponseCardinality(
   declaration: QtiResponseDeclaration,
   value: QtiValue,
   diagnostics: QtiResponseValidationDiagnostic[],
-): void {
-  if (value === null) return;
+): boolean {
+  if (value === null) return true;
 
-  if (matchesCardinality(declaration.cardinality, value)) return;
+  if (matchesCardinality(declaration.cardinality, value)) return true;
   diagnostics.push({
     code: "response.cardinality",
     severity: "error",
@@ -196,6 +227,138 @@ function validateResponseCardinality(
     path: declaration.identifier,
     source: declaration.source,
   });
+  return false;
+}
+
+function parseResponseBaseType(
+  declaration: QtiResponseDeclaration,
+  value: QtiValue,
+  diagnostics: QtiResponseValidationDiagnostic[],
+): QtiValue | undefined {
+  const baseType = declaration.baseType;
+  if (value === null || baseType === undefined || isRecordValue(value)) return value;
+
+  if (Array.isArray(value)) {
+    const parsedValues: QtiScalarValue[] = [];
+    for (const entry of value) {
+      const parsedValue = parseQtiScalarForBaseType(entry, baseType);
+      if (parsedValue === undefined) {
+        pushResponseBaseTypeDiagnostic(declaration, entry, baseType, diagnostics);
+        return undefined;
+      }
+      parsedValues.push(parsedValue);
+    }
+    return parsedValues;
+  }
+
+  const parsedValue = parseQtiScalarForBaseType(value, baseType);
+  if (parsedValue !== undefined) return parsedValue;
+  pushResponseBaseTypeDiagnostic(declaration, value, baseType, diagnostics);
+  return undefined;
+}
+
+function pushResponseBaseTypeDiagnostic(
+  declaration: QtiResponseDeclaration,
+  value: QtiScalarValue,
+  baseType: QtiBaseType,
+  diagnostics: QtiResponseValidationDiagnostic[],
+): void {
+  diagnostics.push({
+    code: "response.baseType",
+    severity: "error",
+    identifier: declaration.identifier,
+    message: `Response ${declaration.identifier} value ${qtiValueToString(value)} is not valid for base-type ${baseType}.`,
+    path: declaration.identifier,
+    source: declaration.source,
+  });
+}
+
+function validateResponseDomain(
+  declaration: QtiResponseDeclaration,
+  interactions: readonly QtiInteraction[],
+  value: QtiValue,
+  diagnostics: QtiResponseValidationDiagnostic[],
+): void {
+  if (value === null) return;
+  const interactionsWithChoices = interactions.filter((interaction) =>
+    interaction.choices.some((choice) => choice.identifier.length > 0),
+  );
+  const baseType = declaration.baseType;
+  if (
+    interactionsWithChoices.length > 0 &&
+    (baseType === "identifier" || baseType === "pair" || baseType === "directedPair")
+  ) {
+    const invalidValue = valueContainer(value).find(
+      (entry) =>
+        typeof entry !== "string" ||
+        !interactionsWithChoices.some((interaction) =>
+          interactionAcceptsResponseValue(interaction, baseType, entry),
+        ),
+    );
+    if (invalidValue !== undefined) {
+      pushResponseDomainDiagnostic(declaration, invalidValue, diagnostics);
+      return;
+    }
+  }
+
+  for (const interaction of interactions) {
+    if (interaction.type !== "slider") continue;
+    const definition = parseQtiSliderDefinition(interaction);
+    if (!definition.ok || parseQtiSliderValue(value, definition.value).ok) continue;
+    pushResponseDomainDiagnostic(declaration, value, diagnostics);
+    return;
+  }
+}
+
+function interactionAcceptsResponseValue(
+  interaction: QtiInteraction,
+  baseType: "identifier" | "pair" | "directedPair",
+  value: string,
+): boolean {
+  const parts = value.trim().split(/\s+/);
+  const identifiers = new Set(
+    interaction.choices.flatMap((choice) => (choice.identifier ? [choice.identifier] : [])),
+  );
+  if (baseType === "identifier") return parts.length === 1 && identifiers.has(parts[0] ?? "");
+  if (parts.length !== 2) return false;
+
+  const sourceIdentifiers = choiceIdentifiersForRoles(interaction, ["matchSource", "gapChoice"]);
+  const targetIdentifiers = choiceIdentifiersForRoles(interaction, [
+    "matchTarget",
+    "gap",
+    "hotspot",
+  ]);
+  if (baseType === "directedPair" && sourceIdentifiers.size > 0 && targetIdentifiers.size > 0) {
+    return sourceIdentifiers.has(parts[0] ?? "") && targetIdentifiers.has(parts[1] ?? "");
+  }
+  return parts.every((part) => identifiers.has(part));
+}
+
+function choiceIdentifiersForRoles(
+  interaction: QtiInteraction,
+  roles: readonly QtiInteraction["choices"][number]["role"][],
+): Set<string> {
+  const acceptedRoles = new Set(roles);
+  return new Set(
+    interaction.choices.flatMap((choice) =>
+      choice.identifier && acceptedRoles.has(choice.role) ? [choice.identifier] : [],
+    ),
+  );
+}
+
+function pushResponseDomainDiagnostic(
+  declaration: QtiResponseDeclaration,
+  value: QtiValue,
+  diagnostics: QtiResponseValidationDiagnostic[],
+): void {
+  diagnostics.push({
+    code: "response.domain",
+    severity: "error",
+    identifier: declaration.identifier,
+    message: `Response ${declaration.identifier} value ${qtiValueToString(value)} is not in the authored interaction domain.`,
+    path: declaration.identifier,
+    source: declaration.source,
+  });
 }
 
 function matchesCardinality(cardinality: QtiCardinality, value: QtiValue): boolean {
@@ -291,6 +454,8 @@ function isResponseValidationDiagnosticCode(
     code === "response.maximum" ||
     code === "response.matchMax" ||
     code === "response.cardinality" ||
+    code === "response.baseType" ||
+    code === "response.domain" ||
     code === "response.undeclared" ||
     code === "response.identifier.required" ||
     code === "response.value.invalid"

package/src/session.ts

@@ -410,6 +410,7 @@ function applyResponseProcessing(context: SessionProcessingContext): void {
           evaluation.responses.RESPONSE ?? null,
           evaluation.correctResponses.RESPONSE ?? null,
           declaration.cardinality === "ordered",
+          declaration.baseType,
         )
       : null;
     evaluation.outcomes.SCORE = matches === true ? 1 : 0;

package/src/trusted-item-session.ts

@@ -1,6 +1,6 @@
 import { parseQtiXml } from "./parser.js";
 import { itemExpectsAutomatedScore } from "./item-scoring-expectation.js";
-import { validateQtiResponseVariables } from "./response-validation.js";
+import { parseQtiResponseVariables } from "./response-validation.js";
 import { createItemSession, isQtiAttemptStateV1, type QtiItemSession } from "./session.js";
 import type {
   QtiAttemptStateV1,
@@ -163,8 +163,9 @@ export function runTrustedItemSession(
 
   if (input.attemptStatus) sessionResult.session.setStatus(input.attemptStatus);
 
+  let submission = input.submission;
   if (input.submissionValidation === "strict") {
-    const validation = validateQtiResponseVariables({
+    const validation = parseQtiResponseVariables({
       item: parsedResult.parsed.document.item,
       responses: input.submission.trustedResponses ?? {},
       allowIncompleteResponses: input.allowIncompleteResponses,
@@ -173,12 +174,13 @@ export function runTrustedItemSession(
     if (!validation.ok) {
       return emptyTrustedItemSessionFailure(validation.diagnostics);
     }
+    submission = { ...input.submission, trustedResponses: validation.responses };
   }
 
   const applicationResult = applyTrustedResponseApplication(
     sessionResult.session,
     parsedResult.parsed,
-    input.submission,
+    submission,
     input.allowedUndeclaredResponseIdentifiers,
     input.diagnosticPrefix,
   );