@longsightgroup/qti3-core 0.9.1 → 0.9.3

package/src/validation.ts

@@ -3,31 +3,40 @@ import type {
   QtiBaseType,
   QtiCatalogCard,
   QtiCatalogCardEntry,
-  QtiCardinality,
-  QtiChoice,
-  QtiElementContent,
   QtiContentNode,
   QtiDiagnostic,
   QtiDocument,
-  QtiInteraction,
   QtiOutcomeDeclaration,
-  QtiProcessingExpression,
-  QtiResponseCondition,
   QtiResponseDeclaration,
-  QtiResponseRule,
-  QtiSetOutcomeValue,
   QtiTemplateDeclaration,
-  QtiTemplateRule,
   QtiValue,
   QtiValidationResult,
 } from "./types.js";
-import { validateInteractionSharedVocabulary } from "./shared-vocabulary-interaction-validation.js";
-import { isValidQtiPatternMask } from "./pattern-mask.js";
+import { assertNever } from "./assert-never.js";
 import { validateQtiDataSsmlMetadata } from "./tts.js";
-import { qtiValueToStringList } from "./value-format.js";
 import { validateCompanionMaterials } from "./validation-companion-materials.js";
-
-const BUILT_IN_COMPLETION_STATUS = "completionStatus";
+import {
+  hasValidShapeCoordinateCount,
+  isAreaShape,
+  isNumericCsv,
+  numericCsv,
+} from "./validation-geometry.js";
+import {
+  isBaseType,
+  isCardinality,
+  isFiniteNumber,
+  isInteger,
+  isPair,
+  isPoint,
+  requireIdentifier,
+} from "./validation-primitives.js";
+import { validateItemBodySharedVocabulary } from "./validation-shared-vocabulary-layout.js";
+import { validateInteractions } from "./validation-interactions.js";
+import {
+  validateProcessingReferences,
+  validateResponseProcessingTemplate,
+} from "./validation-processing.js";
+import { COMPLETION_STATUS } from "./attempt-state-constants.js";
 
 export function validateAssessmentItem(document: QtiDocument): QtiValidationResult {
   const diagnostics: QtiDiagnostic[] = [];
@@ -54,37 +63,6 @@ export function validateAssessmentItem(document: QtiDocument): QtiValidationResu
   };
 }
 
-function validateResponseProcessingTemplate(
-  item: QtiAssessmentItem,
-  diagnostics: QtiDiagnostic[],
-): void {
-  const template = item.responseProcessing?.template;
-  if (!template) return;
-  const templateKind = responseProcessingTemplateKind(template);
-  if (templateKind) {
-    validateBuiltInResponseProcessingTemplate(item, templateKind, diagnostics);
-    return;
-  }
-  diagnostics.push({
-    code: "processing.template.unsupported",
-    severity: "error",
-    message: `qti-response-processing template ${template} is not currently supported.`,
-    path: item.source?.path,
-    source: item.source,
-  });
-}
-
-function responseProcessingTemplateKind(
-  template: string,
-): "matchCorrect" | "mapResponse" | "mapResponsePoint" | undefined {
-  const path = template.split(/[?#]/, 1)[0] ?? "";
-  const name = path.slice(path.lastIndexOf("/") + 1).replace(/\.xml$/i, "");
-  if (name === "match_correct") return "matchCorrect";
-  if (name === "map_response") return "mapResponse";
-  if (name === "map_response_point") return "mapResponsePoint";
-  return undefined;
-}
-
 function validateAssessmentItemRoot(item: QtiAssessmentItem, diagnostics: QtiDiagnostic[]): void {
   if (!item.attributes.title?.trim()) {
     diagnostics.push({
@@ -115,76 +93,6 @@ function validateAssessmentItemRoot(item: QtiAssessmentItem, diagnostics: QtiDia
   }
 }
 
-function validateBuiltInResponseProcessingTemplate(
-  item: QtiAssessmentItem,
-  templateKind: "matchCorrect" | "mapResponse" | "mapResponsePoint",
-  diagnostics: QtiDiagnostic[],
-): void {
-  const response = item.responseDeclarations.find(
-    (declaration) => declaration.identifier === "RESPONSE",
-  );
-  const score = item.outcomeDeclarations.find((declaration) => declaration.identifier === "SCORE");
-  if (!response) {
-    diagnostics.push({
-      code: "processing.template.responseIdentifier",
-      severity: "error",
-      message:
-        "Built-in response-processing templates require a response declaration named RESPONSE.",
-      path: item.source?.path,
-      source: item.source,
-    });
-  }
-  if (!score) {
-    diagnostics.push({
-      code: "processing.template.scoreIdentifier",
-      severity: "error",
-      message: "Built-in response-processing templates require an outcome declaration named SCORE.",
-      path: item.source?.path,
-      source: item.source,
-    });
-  } else if (score.cardinality !== "single" || score.baseType !== "float") {
-    diagnostics.push({
-      code: "processing.template.scoreDeclaration",
-      severity: "error",
-      message:
-        "Built-in response-processing templates require SCORE to be single cardinality with base-type float.",
-      path: score.source?.path,
-      source: score.source,
-    });
-  }
-  const responseInteractions = item.interactions.filter(
-    (interaction) => interaction.responseIdentifier === "RESPONSE",
-  );
-  if (responseInteractions.length !== 1 || item.interactions.length !== 1) {
-    diagnostics.push({
-      code: "processing.template.singleInteraction",
-      severity: "error",
-      message:
-        "Built-in response-processing templates require a single interaction bound to RESPONSE.",
-      path: item.source?.path,
-      source: item.source,
-    });
-  }
-  if (templateKind === "mapResponse" && response && !response.mapping) {
-    diagnostics.push({
-      code: "processing.template.mapping",
-      severity: "error",
-      message: "The map_response template requires RESPONSE to define qti-mapping.",
-      path: response.source?.path,
-      source: response.source,
-    });
-  }
-  if (templateKind === "mapResponsePoint" && response && !response.areaMapping) {
-    diagnostics.push({
-      code: "processing.template.areaMapping",
-      severity: "error",
-      message: "The map_response_point template requires RESPONSE to define qti-area-mapping.",
-      path: response.source?.path,
-      source: response.source,
-    });
-  }
-}
-
 function isXmlBoolean(value: string): boolean {
   return value === "true" || value === "false" || value === "1" || value === "0";
 }
@@ -200,90 +108,6 @@ function validateItemBody(item: QtiAssessmentItem, diagnostics: QtiDiagnostic[])
   });
 }
 
-function validateItemBodySharedVocabulary(
-  item: QtiAssessmentItem,
-  diagnostics: QtiDiagnostic[],
-): void {
-  validateContentSharedVocabulary(item.body, diagnostics);
-}
-
-function validateContentSharedVocabulary(
-  nodes: QtiContentNode[],
-  diagnostics: QtiDiagnostic[],
-): void {
-  for (const node of nodes) {
-    if (node.kind !== "element") continue;
-    validateLayoutVocabularyClasses(node, diagnostics);
-    if (sharedClassNames(node.attributes).includes("qti-layout-row")) {
-      validateLayoutRow(node, diagnostics);
-    }
-    validateContentSharedVocabulary(node.children, diagnostics);
-  }
-}
-
-function validateLayoutVocabularyClasses(
-  node: QtiElementContent,
-  diagnostics: QtiDiagnostic[],
-): void {
-  const classNames = sharedClassNames(node.attributes);
-  for (const className of classNames) {
-    if (isLayoutColumnClassName(className) && layoutColumnValue(className) === undefined) {
-      diagnostics.push({
-        code: "item.sharedVocabulary.layoutColumnInvalid",
-        severity: "warning",
-        message: `Shared vocabulary class ${className} is not supported; expected qti-layout-col1 through qti-layout-col12, or dashed qti-layout-col-1 through qti-layout-col-12.`,
-        path: node.source?.path,
-        source: node.source,
-      });
-    }
-    if (isLayoutOffsetClassName(className) && layoutOffsetValue(className) === undefined) {
-      diagnostics.push({
-        code: "item.sharedVocabulary.layoutOffsetInvalid",
-        severity: "warning",
-        message: `Shared vocabulary class ${className} is not supported; expected qti-layout-offset1 through qti-layout-offset11, or dashed qti-layout-offset-1 through qti-layout-offset-11.`,
-        path: node.source?.path,
-        source: node.source,
-      });
-    }
-  }
-}
-
-function validateLayoutRow(node: QtiElementContent, diagnostics: QtiDiagnostic[]): void {
-  let totalColumns = 0;
-  for (const child of node.children) {
-    if (child.kind !== "element") continue;
-    const classNames = sharedClassNames(child.attributes);
-    const column = firstLayoutColumnValue(classNames);
-    if (column === undefined) continue;
-    totalColumns += (firstLayoutOffsetValue(classNames) ?? 0) + column;
-  }
-  if (totalColumns <= 12) return;
-  diagnostics.push({
-    code: "item.sharedVocabulary.layoutRowOverflow",
-    severity: "warning",
-    message: `qti-layout-row column groupings plus offsets total ${totalColumns}; the QTI shared vocabulary grid allows at most twelve columns per row.`,
-    path: node.source?.path,
-    source: node.source,
-  });
-}
-
-function requireIdentifier(
-  elementName: string,
-  identifier: string | undefined,
-  diagnostics: QtiDiagnostic[],
-  source?: QtiDiagnostic["source"],
-): void {
-  if (!identifier || identifier.trim().length === 0) {
-    diagnostics.push({
-      code: "identifier.required",
-      severity: "error",
-      message: `${elementName} requires a non-empty identifier.`,
-      path: source?.path,
-      source,
-    });
-  }
-}
-
 function validateDeclarationIdentifiers(
   item: QtiAssessmentItem,
   diagnostics: QtiDiagnostic[],
@@ -302,7 +126,7 @@ function validateDeclarationIdentifiers(
     );
     validateDeclarationRequiredAttributes(declaration, diagnostics);
     validateDeclarationValueMetadata(declaration, diagnostics);
-    if (declaration.kind === "outcome" && declaration.identifier === BUILT_IN_COMPLETION_STATUS) {
+    if (declaration.kind === "outcome" && declaration.identifier === COMPLETION_STATUS) {
       diagnostics.push({
         code: "declaration.outcome.builtIn",
         severity: "error",
@@ -408,6 +232,8 @@ function isValidDeclarationBaseValue(value: string, baseType: QtiBaseType): bool
     case "file":
     case "uri":
       return true;
+    default:
+      return assertNever(baseType);
   }
 }
 
@@ -855,1891 +681,32 @@ function validateCatalogHtmlContent(nodes: QtiContentNode[], diagnostics: QtiDia
   }
 }
 
-function validateProcessingReferences(item: QtiAssessmentItem, diagnostics: QtiDiagnostic[]): void {
-  const responses = new Set(item.responseDeclarations.map((declaration) => declaration.identifier));
-  const outcomes = new Set(item.outcomeDeclarations.map((declaration) => declaration.identifier));
-  outcomes.add(BUILT_IN_COMPLETION_STATUS);
-  const templates = new Set(item.templateDeclarations.map((declaration) => declaration.identifier));
-  const variables = new Set([...responses, ...outcomes, ...templates]);
-
-  for (const rule of item.templateProcessing?.rules ?? []) {
-    validateTemplateRule(rule, responses, outcomes, templates, variables, diagnostics);
-  }
-
-  for (const rule of item.responseProcessing?.rules ?? []) {
-    validateResponseRule(rule, outcomes, responses, variables, diagnostics);
-  }
-}
-
-function validateResponseCondition(
-  condition: QtiResponseCondition,
-  outcomes: Set<string>,
-  responses: Set<string>,
-  variables: Set<string>,
-  diagnostics: QtiDiagnostic[],
-): void {
-  validateExpressionReferences(condition.ifExpression, responses, variables, diagnostics);
-  for (const rule of condition.thenRules) {
-    validateResponseRule(rule, outcomes, responses, variables, diagnostics);
-  }
-  for (const branch of condition.elseIfs) {
-    validateExpressionReferences(branch.expression, responses, variables, diagnostics);
-    for (const rule of branch.rules) {
-      validateResponseRule(rule, outcomes, responses, variables, diagnostics);
-    }
-  }
-  for (const rule of condition.elseRules) {
-    validateResponseRule(rule, outcomes, responses, variables, diagnostics);
-  }
-}
-
-function validateTemplateRule(
-  rule: QtiTemplateRule,
-  responses: Set<string>,
-  outcomes: Set<string>,
-  templates: Set<string>,
-  variables: Set<string>,
-  diagnostics: QtiDiagnostic[],
-): void {
-  if (rule.type === "exitTemplate") return;
-  if (rule.type === "templateConstraint") {
-    validateExpressionReferences(rule.expression, responses, variables, diagnostics);
-    return;
-  }
-
-  if (rule.type === "templateCondition") {
-    validateExpressionReferences(rule.ifExpression, responses, variables, diagnostics);
-    for (const branchRule of rule.thenRules) {
-      validateTemplateRule(branchRule, responses, outcomes, templates, variables, diagnostics);
-    }
-    for (const branch of rule.elseIfs) {
-      validateExpressionReferences(branch.expression, responses, variables, diagnostics);
-      for (const branchRule of branch.rules) {
-        validateTemplateRule(branchRule, responses, outcomes, templates, variables, diagnostics);
-      }
-    }
-    for (const branchRule of rule.elseRules) {
-      validateTemplateRule(branchRule, responses, outcomes, templates, variables, diagnostics);
-    }
-    return;
-  }
-
-  if (rule.type === "setTemplateValue") {
-    validateProcessingIdentifier(
-      rule.identifier,
-      "processing.templateTarget",
-      rule.source,
-      diagnostics,
-    );
-    if (rule.identifier && !templates.has(rule.identifier)) {
-      diagnostics.push({
-        code: "processing.templateTarget.reference",
-        severity: "error",
-        message: `qti-set-template-value references missing template declaration ${rule.identifier}.`,
-        path: rule.source?.path,
-        source: rule.source,
-      });
-    }
-  }
-
-  if (rule.type === "setDefaultValue") {
-    validateProcessingIdentifier(
-      rule.identifier,
-      "processing.defaultTarget",
-      rule.source,
-      diagnostics,
-    );
-    if (rule.identifier && !responses.has(rule.identifier) && !outcomes.has(rule.identifier)) {
-      diagnostics.push({
-        code: "processing.defaultTarget.reference",
-        severity: "error",
-        message: `qti-set-default-value references missing response or outcome declaration ${rule.identifier}.`,
-        path: rule.source?.path,
-        source: rule.source,
-      });
-    }
-  }
-
-  if (rule.type === "setCorrectResponse") {
-    validateProcessingIdentifier(
-      rule.identifier,
-      "processing.correctResponse",
-      rule.source,
-      diagnostics,
-    );
-    if (rule.identifier && !responses.has(rule.identifier)) {
-      diagnostics.push({
-        code: "processing.correctResponse.reference",
-        severity: "error",
-        message: `qti-set-correct-response references missing response declaration ${rule.identifier}.`,
-        path: rule.source?.path,
-        source: rule.source,
-      });
-    }
-  }
-
-  validateExpressionReferences(rule.expression, responses, variables, diagnostics);
-}
-
-function validateResponseRule(
-  rule: QtiResponseRule,
-  outcomes: Set<string>,
-  responses: Set<string>,
-  variables: Set<string>,
-  diagnostics: QtiDiagnostic[],
-): void {
-  if (rule.type === "exitResponse") return;
-  if (rule.type === "responseCondition") {
-    validateResponseCondition(rule.condition, outcomes, responses, variables, diagnostics);
-    return;
-  }
-  if (rule.type === "responseProcessingFragment") {
-    for (const childRule of rule.rules) {
-      validateResponseRule(childRule, outcomes, responses, variables, diagnostics);
-    }
-    return;
-  }
-  if (rule.type === "lookupOutcomeValue") {
-    validateLookupOutcomeRule(rule, outcomes, responses, variables, diagnostics);
-    return;
-  }
-  validateSetOutcomeRule(rule, outcomes, responses, variables, diagnostics);
-}
-
-function validateLookupOutcomeRule(
-  rule: Extract<QtiResponseRule, { type: "lookupOutcomeValue" }>,
-  outcomes: Set<string>,
-  responses: Set<string>,
-  variables: Set<string>,
-  diagnostics: QtiDiagnostic[],
-): void {
-  validateProcessingIdentifier(
-    rule.identifier,
-    "processing.lookupOutcomeTarget",
-    rule.source,
-    diagnostics,
-  );
-  if (rule.identifier && !outcomes.has(rule.identifier)) {
-    diagnostics.push({
-      code: "processing.lookupOutcomeTarget.reference",
-      severity: "error",
-      message: `qti-lookup-outcome-value references missing outcome declaration ${rule.identifier}.`,
-      path: rule.source?.path,
-      source: rule.source,
-    });
-  }
-  validateExpressionReferences(rule.expression, responses, variables, diagnostics);
-}
-
-function validateSetOutcomeRule(
-  rule: QtiSetOutcomeValue,
-  outcomes: Set<string>,
-  responses: Set<string>,
-  variables: Set<string>,
-  diagnostics: QtiDiagnostic[],
-): void {
-  validateProcessingIdentifier(
-    rule.identifier,
-    "processing.outcomeTarget",
-    rule.source,
-    diagnostics,
+function validateModalFeedback(item: QtiAssessmentItem, diagnostics: QtiDiagnostic[]): void {
+  const outcomeIdentifiers = new Set(
+    item.outcomeDeclarations.map((declaration) => declaration.identifier),
   );
-  if (rule.identifier && !outcomes.has(rule.identifier)) {
-    diagnostics.push({
-      code: "processing.outcomeTarget.reference",
-      severity: "error",
-      message: `qti-set-outcome-value references missing outcome declaration ${rule.identifier}.`,
-      path: rule.source?.path,
-      source: rule.source,
-    });
-  }
-  validateExpressionReferences(rule.expression, responses, variables, diagnostics);
-}
-
-function validateExpressionReferences(
-  expression: QtiProcessingExpression | undefined,
-  responses: Set<string>,
-  variables: Set<string>,
-  diagnostics: QtiDiagnostic[],
-): void {
-  if (!expression) return;
-
-  if (expression.type === "variable" || expression.type === "isNull") {
-    validateProcessingIdentifier(
-      expression.identifier,
-      "processing.variable",
-      expression.source,
-      diagnostics,
-    );
-    if (expression.identifier && !variables.has(expression.identifier)) {
-      diagnostics.push({
-        code: "processing.variable.reference",
-        severity: "error",
-        message: `Processing expression references missing variable ${expression.identifier}.`,
-        path: expression.source?.path,
-        source: expression.source,
-      });
-    }
-  }
-
-  if (expression.type === "matchCorrect") {
-    validateProcessingIdentifier(
-      expression.identifier,
-      "processing.response",
-      expression.source,
-      diagnostics,
-    );
-    if (expression.identifier && !responses.has(expression.identifier)) {
-      diagnostics.push({
-        code: "processing.response.reference",
-        severity: "error",
-        message: `Processing expression references missing response declaration ${expression.identifier}.`,
-        path: expression.source?.path,
-        source: expression.source,
-      });
-    }
-    validateProcessingIdentifier(
-      expression.correctIdentifier,
-      "processing.correct",
-      expression.source,
-      diagnostics,
-    );
-    if (expression.correctIdentifier && !responses.has(expression.correctIdentifier)) {
-      diagnostics.push({
-        code: "processing.correct.reference",
-        severity: "error",
-        message: `Processing expression references missing correct response declaration ${expression.correctIdentifier}.`,
-        path: expression.source?.path,
-        source: expression.source,
-      });
-    }
-  }
-
-  if (expression.type === "mapResponse" || expression.type === "mapResponsePoint") {
-    validateProcessingIdentifier(
-      expression.identifier,
-      "processing.response",
-      expression.source,
-      diagnostics,
-    );
-    if (expression.identifier && !responses.has(expression.identifier)) {
-      diagnostics.push({
-        code: "processing.response.reference",
-        severity: "error",
-        message: `Processing expression references missing response declaration ${expression.identifier}.`,
-        path: expression.source?.path,
-        source: expression.source,
-      });
-    }
-  }
-
-  if (expression.type === "correct") {
-    validateProcessingIdentifier(
-      expression.identifier,
-      "processing.correct",
-      expression.source,
-      diagnostics,
-    );
-    if (expression.identifier && !responses.has(expression.identifier)) {
+  const seen = new Set<string>();
+  for (const feedback of item.modalFeedback) {
+    requireIdentifier("qti-modal-feedback", feedback.identifier, diagnostics, feedback.source);
+    const key = `${feedback.outcomeIdentifier}\n${feedback.identifier}`;
+    if (seen.has(key)) {
       diagnostics.push({
-        code: "processing.correct.reference",
+        code: "feedback.identifier.duplicate",
         severity: "error",
-        message: `Processing expression references missing correct response declaration ${expression.identifier}.`,
-        path: expression.source?.path,
-        source: expression.source,
+        message: `Duplicate modal feedback ${feedback.identifier} for outcome ${feedback.outcomeIdentifier}.`,
+        path: feedback.source?.path,
+        source: feedback.source,
       });
     }
-  }
-
-  if (expression.type === "default") {
-    validateProcessingIdentifier(
-      expression.identifier,
-      "processing.variable",
-      expression.source,
-      diagnostics,
-    );
-    if (expression.identifier && !variables.has(expression.identifier)) {
+    seen.add(key);
+    if (!outcomeIdentifiers.has(feedback.outcomeIdentifier)) {
       diagnostics.push({
-        code: "processing.variable.reference",
+        code: "feedback.outcomeIdentifier.reference",
         severity: "error",
-        message: `Processing expression references missing variable ${expression.identifier}.`,
-        path: expression.source?.path,
-        source: expression.source,
+        message: `qti-modal-feedback ${feedback.identifier} references missing outcome declaration ${feedback.outcomeIdentifier}.`,
+        path: feedback.source?.path,
+        source: feedback.source,
       });
     }
   }
-
-  if (expression.type === "randomInteger") {
-    validateRandomIntegerExpression(expression, diagnostics);
-  }
-
-  if (expression.type === "randomFloat") {
-    validateRandomFloatExpression(expression, diagnostics);
-  }
-
-  if (expression.type === "baseValue") {
-    validateBaseValueExpression(expression, diagnostics);
-  }
-
-  if (expression.type === "equalRounded") {
-    validateRounding(
-      "qti-equal-rounded",
-      expression.roundingMode,
-      expression.figures,
-      diagnostics,
-      expression.source,
-    );
-  }
-
-  if (expression.type === "mathConstant" && !mathConstantNames.has(expression.name)) {
-    diagnostics.push({
-      code: "processing.mathConstant.name",
-      severity: "error",
-      message: `qti-math-constant has unsupported name ${expression.name}.`,
-      path: expression.source?.path,
-      source: expression.source,
-    });
-  }
-
-  if (expression.type === "mathOperator" && !mathOperatorNames.has(expression.name)) {
-    diagnostics.push({
-      code: "processing.mathOperator.name",
-      severity: "error",
-      message: `qti-math-operator has unsupported name ${expression.name}.`,
-      path: expression.source?.path,
-      source: expression.source,
-    });
-  }
-
-  if (expression.type === "statsOperator" && !statsOperatorNames.has(expression.name)) {
-    diagnostics.push({
-      code: "processing.statsOperator.name",
-      severity: "error",
-      message: `qti-stats-operator has unsupported name ${expression.name}.`,
-      path: expression.source?.path,
-      source: expression.source,
-    });
-  }
-
-  if (expression.type === "repeat") {
-    validateRepeatExpression(expression, variables, diagnostics);
-  }
-
-  if (expression.type === "inside") {
-    validateInsideExpression(expression, diagnostics);
-  }
-
-  if (expression.type === "fieldValue") {
-    validateProcessingIdentifier(
-      expression.fieldIdentifier,
-      "processing.fieldValue.fieldIdentifier",
-      expression.source,
-      diagnostics,
-    );
-  }
-
-  for (const child of expressionChildren(expression)) {
-    validateExpressionReferences(child, responses, variables, diagnostics);
-  }
-}
-
-const mathConstantNames = new Set(["pi", "e"]);
-const mathOperatorNames = new Set([
-  "abs",
-  "acos",
-  "acot",
-  "acsc",
-  "asec",
-  "asin",
-  "atan",
-  "atan2",
-  "ceil",
-  "cos",
-  "cosh",
-  "cot",
-  "coth",
-  "csc",
-  "csch",
-  "exp",
-  "floor",
-  "ln",
-  "log",
-  "sec",
-  "sech",
-  "signum",
-  "sin",
-  "sinh",
-  "tan",
-  "tanh",
-  "toDegrees",
-  "toRadians",
-]);
-const statsOperatorNames = new Set(["mean", "sampleVariance", "sampleSD", "popVariance", "popSD"]);
-
-function validateRounding(
-  qtiName: string,
-  roundingMode: string,
-  figures: number,
-  diagnostics: QtiDiagnostic[],
-  source: QtiDiagnostic["source"],
-): void {
-  if (roundingMode !== "decimalPlaces" && roundingMode !== "significantFigures") {
-    diagnostics.push({
-      code: "processing.roundingMode",
-      severity: "error",
-      message: `${qtiName} requires rounding-mode decimalPlaces or significantFigures.`,
-      path: source?.path,
-      source,
-    });
-  }
-  const validFigures =
-    Number.isInteger(figures) && (roundingMode === "decimalPlaces" ? figures >= 0 : figures > 0);
-  if (!validFigures) {
-    diagnostics.push({
-      code: "processing.roundingFigures",
-      severity: "error",
-      message: `${qtiName} requires valid figures for its rounding mode.`,
-      path: source?.path,
-      source,
-    });
-  }
-}
-
-function validateRepeatExpression(
-  expression: Extract<QtiProcessingExpression, { type: "repeat" }>,
-  variables: Set<string>,
-  diagnostics: QtiDiagnostic[],
-): void {
-  if (isInteger(expression.numberRepeats)) return;
-  validateProcessingIdentifier(
-    expression.numberRepeats,
-    "processing.repeat.numberRepeats",
-    expression.source,
-    diagnostics,
-  );
-  if (expression.numberRepeats && !variables.has(expression.numberRepeats)) {
-    diagnostics.push({
-      code: "processing.repeat.numberRepeats.reference",
-      severity: "error",
-      message: `qti-repeat references missing template or outcome variable ${expression.numberRepeats}.`,
-      path: expression.source?.path,
-      source: expression.source,
-    });
-  }
-}
-
-function validateInsideExpression(
-  expression: Extract<QtiProcessingExpression, { type: "inside" }>,
-  diagnostics: QtiDiagnostic[],
-): void {
-  const rawShape = expression.attributes.shape;
-  if (rawShape === undefined) {
-    diagnostics.push({
-      code: "processing.inside.shape.required",
-      severity: "error",
-      message: "qti-inside requires shape.",
-      path: expression.source?.path,
-      source: expression.source,
-    });
-  } else if (
-    rawShape !== "circle" &&
-    rawShape !== "rect" &&
-    rawShape !== "poly" &&
-    rawShape !== "default"
-  ) {
-    diagnostics.push({
-      code: "processing.inside.shape",
-      severity: "error",
-      message: `qti-inside has unsupported shape ${rawShape}.`,
-      path: expression.source?.path,
-      source: expression.source,
-    });
-  }
-
-  const expectedCoordCount =
-    rawShape === "circle" ? 3 : rawShape === "rect" ? 4 : rawShape === "default" ? 0 : undefined;
-  if (expectedCoordCount !== undefined && expression.coords.length !== expectedCoordCount) {
-    diagnostics.push({
-      code: "processing.inside.coords",
-      severity: "error",
-      message: `qti-inside shape ${rawShape} requires ${expectedCoordCount} coordinates.`,
-      path: expression.source?.path,
-      source: expression.source,
-    });
-  }
-  if (rawShape === "poly" && (expression.coords.length < 6 || expression.coords.length % 2 !== 0)) {
-    diagnostics.push({
-      code: "processing.inside.coords",
-      severity: "error",
-      message: "qti-inside poly requires an even number of at least 6 coordinates.",
-      path: expression.source?.path,
-      source: expression.source,
-    });
-  }
-}
-
-function validateBaseValueExpression(
-  expression: Extract<QtiProcessingExpression, { type: "baseValue" }>,
-  diagnostics: QtiDiagnostic[],
-): void {
-  if (!expression.baseType) {
-    diagnostics.push({
-      code: "processing.baseValue.baseType.required",
-      severity: "error",
-      message: "qti-base-value requires base-type.",
-      path: expression.source?.path,
-      source: expression.source,
-    });
-    return;
-  }
-  if (!isBaseType(expression.baseType)) {
-    diagnostics.push({
-      code: "processing.baseValue.baseType",
-      severity: "error",
-      message: `qti-base-value has unsupported base-type ${expression.baseType}.`,
-      path: expression.source?.path,
-      source: expression.source,
-    });
-    return;
-  }
-  const value = expression.rawValue ?? "";
-  if (
-    (expression.baseType === "integer" && !isInteger(value)) ||
-    (expression.baseType === "float" && !isFiniteNumber(value))
-  ) {
-    diagnostics.push({
-      code: "processing.baseValue.numeric",
-      severity: "error",
-      message: `qti-base-value requires ${expression.baseType} content, got ${value}.`,
-      path: expression.source?.path,
-      source: expression.source,
-    });
-  }
-  if (expression.baseType === "boolean" && value !== "true" && value !== "false") {
-    diagnostics.push({
-      code: "processing.baseValue.boolean",
-      severity: "error",
-      message: `qti-base-value requires boolean content, got ${value}.`,
-      path: expression.source?.path,
-      source: expression.source,
-    });
-  }
-}
-
-function validateRandomIntegerExpression(
-  expression: Extract<QtiProcessingExpression, { type: "randomInteger" }>,
-  diagnostics: QtiDiagnostic[],
-): void {
-  validateRandomIntegerAttribute(expression, "min", diagnostics);
-  validateRandomIntegerAttribute(expression, "max", diagnostics);
-
-  if (expression.attributes.step !== undefined) {
-    validateRandomIntegerAttribute(expression, "step", diagnostics);
-    if (isInteger(expression.attributes.step) && Number(expression.attributes.step) <= 0) {
-      diagnostics.push({
-        code: "processing.randomInteger.step",
-        severity: "error",
-        message: "qti-random-integer requires step to be greater than 0.",
-        path: expression.source?.path,
-        source: expression.source,
-      });
-    }
-  }
-
-  const min = expression.attributes.min;
-  const max = expression.attributes.max;
-  if (
-    min !== undefined &&
-    max !== undefined &&
-    isInteger(min) &&
-    isInteger(max) &&
-    Number(min) > Number(max)
-  ) {
-    diagnostics.push({
-      code: "processing.randomInteger.bounds",
-      severity: "error",
-      message: "qti-random-integer requires min to be less than or equal to max.",
-      path: expression.source?.path,
-      source: expression.source,
-    });
-  }
-}
-
-function validateRandomIntegerAttribute(
-  expression: Extract<QtiProcessingExpression, { type: "randomInteger" }>,
-  attribute: "min" | "max" | "step",
-  diagnostics: QtiDiagnostic[],
-): void {
-  const value = expression.attributes[attribute];
-  if (value === undefined) {
-    diagnostics.push({
-      code: "processing.randomInteger.attribute",
-      severity: "error",
-      message: `qti-random-integer requires ${attribute}.`,
-      path: expression.source?.path,
-      source: expression.source,
-    });
-    return;
-  }
-  if (isInteger(value)) return;
-  diagnostics.push({
-    code: "processing.randomInteger.integer",
-    severity: "error",
-    message: `qti-random-integer requires integer ${attribute}, got ${value}.`,
-    path: expression.source?.path,
-    source: expression.source,
-  });
-}
-
-function validateRandomFloatExpression(
-  expression: Extract<QtiProcessingExpression, { type: "randomFloat" }>,
-  diagnostics: QtiDiagnostic[],
-): void {
-  validateRandomFloatAttribute(expression, "max", diagnostics);
-  if (expression.attributes.min !== undefined)
-    validateRandomFloatAttribute(expression, "min", diagnostics);
-
-  const min = expression.attributes.min ?? "0";
-  const max = expression.attributes.max;
-  if (
-    max !== undefined &&
-    isFiniteNumber(min) &&
-    isFiniteNumber(max) &&
-    Number(min) > Number(max)
-  ) {
-    diagnostics.push({
-      code: "processing.randomFloat.bounds",
-      severity: "error",
-      message: "qti-random-float requires min to be less than or equal to max.",
-      path: expression.source?.path,
-      source: expression.source,
-    });
-  }
-}
-
-function validateRandomFloatAttribute(
-  expression: Extract<QtiProcessingExpression, { type: "randomFloat" }>,
-  attribute: "min" | "max",
-  diagnostics: QtiDiagnostic[],
-): void {
-  const value = expression.attributes[attribute];
-  if (value === undefined) {
-    diagnostics.push({
-      code: "processing.randomFloat.attribute",
-      severity: "error",
-      message: `qti-random-float requires ${attribute}.`,
-      path: expression.source?.path,
-      source: expression.source,
-    });
-    return;
-  }
-  if (isFiniteNumber(value)) return;
-  diagnostics.push({
-    code: "processing.randomFloat.numeric",
-    severity: "error",
-    message: `qti-random-float requires numeric ${attribute}, got ${value}.`,
-    path: expression.source?.path,
-    source: expression.source,
-  });
-}
-
-function validateProcessingIdentifier(
-  identifier: string,
-  code: string,
-  source: QtiDiagnostic["source"],
-  diagnostics: QtiDiagnostic[],
-): void {
-  if (identifier.trim().length > 0) return;
-  diagnostics.push({
-    code,
-    severity: "error",
-    message: "Processing rule requires a non-empty identifier.",
-    path: source?.path,
-    source,
-  });
-}
-
-function expressionChildren(expression: QtiProcessingExpression): QtiProcessingExpression[] {
-  if (expression.type === "random") {
-    return expression.values;
-  }
-  if (
-    expression.type === "multiple" ||
-    expression.type === "ordered" ||
-    expression.type === "sum" ||
-    expression.type === "product" ||
-    expression.type === "min" ||
-    expression.type === "max" ||
-    expression.type === "and" ||
-    expression.type === "anyN" ||
-    expression.type === "or" ||
-    expression.type === "gcd" ||
-    expression.type === "lcm" ||
-    expression.type === "mathOperator" ||
-    expression.type === "repeat" ||
-    expression.type === "customOperator"
-  ) {
-    return expression.expressions;
-  }
-  if (
-    expression.type === "subtract" ||
-    expression.type === "divide" ||
-    expression.type === "power" ||
-    expression.type === "integerDivide" ||
-    expression.type === "integerModulus" ||
-    expression.type === "match" ||
-    expression.type === "equal" ||
-    expression.type === "equalRounded" ||
-    expression.type === "numericCompare" ||
-    expression.type === "durationCompare"
-  ) {
-    return [expression.left, expression.right];
-  }
-  if (
-    expression.type === "not" ||
-    expression.type === "round" ||
-    expression.type === "roundTo" ||
-    expression.type === "truncate" ||
-    expression.type === "integerToFloat" ||
-    expression.type === "index" ||
-    expression.type === "containerSize" ||
-    expression.type === "patternMatch" ||
-    expression.type === "fieldValue" ||
-    expression.type === "inside"
-  ) {
-    return [expression.expression];
-  }
-  if (expression.type === "stringMatch" || expression.type === "substring") {
-    return [expression.left, expression.right];
-  }
-  if (expression.type === "member") {
-    return [expression.value, expression.collection];
-  }
-  if (expression.type === "delete") {
-    return [expression.value, expression.collection];
-  }
-  if (expression.type === "contains") {
-    return [expression.collection, expression.values];
-  }
-  if (expression.type === "statsOperator") {
-    return [expression.expression];
-  }
-  return [];
-}
-
-function validateModalFeedback(item: QtiAssessmentItem, diagnostics: QtiDiagnostic[]): void {
-  const outcomeIdentifiers = new Set(
-    item.outcomeDeclarations.map((declaration) => declaration.identifier),
-  );
-  const seen = new Set<string>();
-  for (const feedback of item.modalFeedback) {
-    requireIdentifier("qti-modal-feedback", feedback.identifier, diagnostics, feedback.source);
-    const key = `${feedback.outcomeIdentifier}\n${feedback.identifier}`;
-    if (seen.has(key)) {
-      diagnostics.push({
-        code: "feedback.identifier.duplicate",
-        severity: "error",
-        message: `Duplicate modal feedback ${feedback.identifier} for outcome ${feedback.outcomeIdentifier}.`,
-        path: feedback.source?.path,
-        source: feedback.source,
-      });
-    }
-    seen.add(key);
-    if (!outcomeIdentifiers.has(feedback.outcomeIdentifier)) {
-      diagnostics.push({
-        code: "feedback.outcomeIdentifier.reference",
-        severity: "error",
-        message: `qti-modal-feedback ${feedback.identifier} references missing outcome declaration ${feedback.outcomeIdentifier}.`,
-        path: feedback.source?.path,
-        source: feedback.source,
-      });
-    }
-  }
-}
-
-function validateInteractions(item: QtiAssessmentItem, diagnostics: QtiDiagnostic[]): void {
-  const responseDeclarations = new Map(
-    item.responseDeclarations.map((declaration) => [declaration.identifier, declaration]),
-  );
-  const responseIdentifiers = new Set(responseDeclarations.keys());
-  for (const interaction of item.interactions) {
-    validateInteractionResponseReference(interaction, responseIdentifiers, diagnostics);
-    validateInteractionResponseShape(interaction, diagnostics);
-    validateInteractionSharedVocabulary(interaction, diagnostics);
-    validateInteractionChoices(interaction, diagnostics);
-    validateInteractionChildren(interaction, diagnostics);
-    validateInteractionRequiredAttributes(interaction, diagnostics);
-    validatePortableCustomInteraction(interaction, item, diagnostics);
-    validateInteractionLimitAttributes(interaction, diagnostics);
-    validatePatternMaskAttribute(interaction, diagnostics);
-    validateGraphicHotspotObjectDimensions(interaction, diagnostics);
-    validateCorrectResponseReferences(
-      interaction,
-      interaction.responseIdentifier
-        ? responseDeclarations.get(interaction.responseIdentifier)
-        : undefined,
-      diagnostics,
-    );
-    validateMappingReferences(
-      interaction,
-      interaction.responseIdentifier
-        ? responseDeclarations.get(interaction.responseIdentifier)
-        : undefined,
-      diagnostics,
-    );
-  }
-}
-
-function sharedClassNames(attributes: Record<string, string>): string[] {
-  return (attributes.class ?? "").split(/\s+/).filter(Boolean);
-}
-
-function isLayoutColumnClassName(className: string): boolean {
-  return /^qti-layout-col-?\w+$/.test(className);
-}
-
-function layoutColumnValue(className: string): number | undefined {
-  const rawValue = /^qti-layout-col-?(\d+)$/.exec(className)?.[1];
-  if (rawValue === undefined) return undefined;
-  const value = Number(rawValue);
-  if (value < 1 || value > 12) return undefined;
-  return value;
-}
-
-function firstLayoutColumnValue(classNames: string[]): number | undefined {
-  for (const className of classNames) {
-    const value = layoutColumnValue(className);
-    if (value !== undefined) return value;
-  }
-  return undefined;
-}
-
-function isLayoutOffsetClassName(className: string): boolean {
-  return /^qti-layout-offset-?\w+$/.test(className);
-}
-
-function layoutOffsetValue(className: string): number | undefined {
-  const rawValue = /^qti-layout-offset-?(\d+)$/.exec(className)?.[1];
-  if (rawValue === undefined) return undefined;
-  const value = Number(rawValue);
-  if (value < 1 || value > 11) return undefined;
-  return value;
-}
-
-function firstLayoutOffsetValue(classNames: string[]): number | undefined {
-  for (const className of classNames) {
-    const value = layoutOffsetValue(className);
-    if (value !== undefined) return value;
-  }
-  return undefined;
-}
-
-function validateInteractionResponseReference(
-  interaction: QtiInteraction,
-  responseIdentifiers: Set<string>,
-  diagnostics: QtiDiagnostic[],
-): void {
-  if (!interaction.responseIdentifier) {
-    if (interaction.type !== "endAttempt") {
-      diagnostics.push({
-        code: "interaction.responseIdentifier",
-        severity: "error",
-        message: `${interaction.qtiName} is missing response-identifier.`,
-        path: interaction.source?.path,
-        source: interaction.source,
-      });
-    }
-    return;
-  }
-
-  if (!responseIdentifiers.has(interaction.responseIdentifier)) {
-    diagnostics.push({
-      code: "interaction.responseIdentifier.reference",
-      severity: "error",
-      message: `${interaction.qtiName} references missing response declaration ${interaction.responseIdentifier}.`,
-      path: interaction.source?.path,
-      source: interaction.source,
-    });
-  }
-}
-
-function validateInteractionResponseShape(
-  interaction: QtiInteraction,
-  diagnostics: QtiDiagnostic[],
-): void {
-  const expected = expectedResponseShape(interaction);
-  if (!expected) return;
-
-  if (
-    interaction.responseCardinality &&
-    !expected.cardinalities.includes(interaction.responseCardinality)
-  ) {
-    diagnostics.push({
-      code: "interaction.cardinality",
-      severity: "error",
-      message: `${interaction.qtiName} expects ${expected.cardinalities.join(" or ")} cardinality, got ${interaction.responseCardinality}.`,
-      path: interaction.source?.path,
-      source: interaction.source,
-    });
-  }
-
-  if (interaction.responseBaseType && !expected.baseTypes.includes(interaction.responseBaseType)) {
-    diagnostics.push({
-      code: "interaction.baseType",
-      severity: "error",
-      message: `${interaction.qtiName} expects ${expected.baseTypes.join(" or ")} base type, got ${interaction.responseBaseType}.`,
-      path: interaction.source?.path,
-      source: interaction.source,
-    });
-  }
-}
-
-function validateInteractionChoices(
-  interaction: QtiInteraction,
-  diagnostics: QtiDiagnostic[],
-): void {
-  const identifiers = new Set<string>();
-  for (const choice of interaction.choices) {
-    requireIdentifier(choice.qtiName, choice.attributes.identifier, diagnostics, choice.source);
-    if (!choice.identifier) continue;
-    if (identifiers.has(choice.identifier)) {
-      diagnostics.push({
-        code: "choice.identifier.duplicate",
-        severity: "error",
-        message: `${interaction.qtiName} has duplicate choice identifier ${choice.identifier}.`,
-        path: choice.source?.path ?? interaction.source?.path,
-        source: choice.source ?? interaction.source,
-      });
-    }
-    identifiers.add(choice.identifier);
-  }
-
-  if (
-    needsChoices(interaction) &&
-    interaction.choices.filter((choice) => choice.role !== "gap").length === 0
-  ) {
-    diagnostics.push({
-      code: "interaction.choices.required",
-      severity: "error",
-      message: `${interaction.qtiName} requires at least one choice.`,
-      path: interaction.source?.path,
-      source: interaction.source,
-    });
-  }
-
-  for (const choice of interaction.choices) {
-    validateChoiceLimitAttributes(choice, diagnostics);
-  }
-}
-
-function validateCorrectResponseReferences(
-  interaction: QtiInteraction,
-  declaration: QtiResponseDeclaration | undefined,
-  diagnostics: QtiDiagnostic[],
-): void {
-  if (!declaration || declaration.correctResponse === null) return;
-  if (
-    declaration.baseType !== "identifier" &&
-    declaration.baseType !== "pair" &&
-    declaration.baseType !== "directedPair"
-  ) {
-    return;
-  }
-
-  const identifiers = new Set(
-    interaction.choices
-      .map((choice) => choice.identifier)
-      .filter((identifier) => identifier.length > 0),
-  );
-  if (identifiers.size === 0) return;
-
-  for (const value of responseValues(declaration.correctResponse)) {
-    if (declaration.baseType === "identifier") {
-      if (identifiers.has(value)) continue;
-      invalidCorrectResponseReference(interaction, declaration, value, diagnostics);
-      continue;
-    }
-
-    const parts = value.trim().split(/\s+/);
-    if (parts.length !== 2 || parts.some((part) => !identifiers.has(part))) {
-      invalidCorrectResponseReference(interaction, declaration, value, diagnostics);
-    }
-  }
-}
-
-function responseValues(value: QtiResponseDeclaration["correctResponse"]): string[] {
-  return qtiValueToStringList(value);
-}
-
-function invalidCorrectResponseReference(
-  interaction: QtiInteraction,
-  declaration: QtiResponseDeclaration,
-  value: string,
-  diagnostics: QtiDiagnostic[],
-): void {
-  diagnostics.push({
-    code: "response.correctResponse.reference",
-    severity: "error",
-    message: `Response declaration ${declaration.identifier} correct response ${value} does not reference choices in ${interaction.qtiName}.`,
-    path: declaration.source?.path,
-    source: declaration.source,
-  });
-}
-
-function validateMappingReferences(
-  interaction: QtiInteraction,
-  declaration: QtiResponseDeclaration | undefined,
-  diagnostics: QtiDiagnostic[],
-): void {
-  if (!declaration?.mapping) return;
-  if (
-    declaration.baseType !== "identifier" &&
-    declaration.baseType !== "pair" &&
-    declaration.baseType !== "directedPair"
-  ) {
-    return;
-  }
-
-  const identifiers = new Set(
-    interaction.choices
-      .map((choice) => choice.identifier)
-      .filter((identifier) => identifier.length > 0),
-  );
-  if (identifiers.size === 0) return;
-
-  for (const entry of declaration.mapping.entries) {
-    const mapKey = entry.mapKey;
-    if (!mapKey) continue;
-    if (declaration.baseType === "identifier") {
-      if (identifiers.has(mapKey)) continue;
-      invalidMappingReference(interaction, declaration, entry, diagnostics);
-      continue;
-    }
-
-    const parts = mapKey.trim().split(/\s+/);
-    if (parts.length !== 2 || parts.some((part) => !identifiers.has(part))) {
-      invalidMappingReference(interaction, declaration, entry, diagnostics);
-    }
-  }
-}
-
-function invalidMappingReference(
-  interaction: QtiInteraction,
-  declaration: QtiResponseDeclaration,
-  entry: NonNullable<QtiResponseDeclaration["mapping"]>["entries"][number],
-  diagnostics: QtiDiagnostic[],
-): void {
-  diagnostics.push({
-    code: "mapping.mapKey.reference",
-    severity: "error",
-    message: `Response declaration ${declaration.identifier} map-key ${entry.mapKey ?? ""} does not reference choices in ${interaction.qtiName}.`,
-    path: entry.source?.path ?? declaration.source?.path,
-    source: entry.source ?? declaration.source,
-  });
-}
-
-function validateInteractionChildren(
-  interaction: QtiInteraction,
-  diagnostics: QtiDiagnostic[],
-): void {
-  const allowed = allowedInteractionChildren(interaction);
-  if (!allowed) return;
-
-  for (const child of interaction.childElements) {
-    if (allowed.has(child.qtiName)) continue;
-    diagnostics.push({
-      code: "interaction.child.unsupported",
-      severity: "error",
-      message: `${interaction.qtiName} does not allow ${child.qtiName} as a direct child.`,
-      path: child.source?.path ?? interaction.source?.path,
-      source: child.source ?? interaction.source,
-    });
-  }
-}
-
-function validateInteractionRequiredAttributes(
-  interaction: QtiInteraction,
-  diagnostics: QtiDiagnostic[],
-): void {
-  if (requiresObject(interaction) && !hasRequiredObjectAsset(interaction)) {
-    diagnostics.push({
-      code: "interaction.object.required",
-      severity: "error",
-      message:
-        interaction.type === "drawing"
-          ? `${interaction.qtiName} requires an object, img, or picture canvas with a data/src attribute.`
-          : `${interaction.qtiName} requires an object, img, audio, or video child with a data/src attribute or media sources.`,
-      path: interaction.source?.path,
-      source: interaction.source,
-    });
-  }
-
-  if (interaction.type === "portableCustom") {
-    requireInteractionAttribute(
-      interaction,
-      "custom-interaction-type-identifier",
-      "interaction.portableCustom.typeIdentifier",
-      diagnostics,
-    );
-  }
-
-  if (interaction.type === "slider") {
-    const lower = interaction.attributes["lower-bound"];
-    const upper = interaction.attributes["upper-bound"];
-    requireInteractionAttribute(
-      interaction,
-      "lower-bound",
-      "interaction.slider.lowerBound",
-      diagnostics,
-    );
-    requireInteractionAttribute(
-      interaction,
-      "upper-bound",
-      "interaction.slider.upperBound",
-      diagnostics,
-    );
-    if (lower !== undefined && !isFiniteNumber(lower)) {
-      invalidNumber(interaction, "lower-bound", lower, diagnostics);
-    }
-    if (upper !== undefined && !isFiniteNumber(upper)) {
-      invalidNumber(interaction, "upper-bound", upper, diagnostics);
-    }
-    if (
-      lower !== undefined &&
-      upper !== undefined &&
-      isFiniteNumber(lower) &&
-      isFiniteNumber(upper)
-    ) {
-      if (Number(lower) >= Number(upper)) {
-        diagnostics.push({
-          code: "interaction.slider.bounds",
-          severity: "error",
-          message: `${interaction.qtiName} requires lower-bound to be less than upper-bound.`,
-          path: interaction.source?.path,
-          source: interaction.source,
-        });
-      }
-    }
-    const step = interaction.attributes.step;
-    if (step !== undefined && (!isFiniteNumber(step) || Number(step) <= 0)) {
-      invalidNumber(interaction, "step", step, diagnostics);
-    }
-  }
-}
-
-function requiresObject(interaction: QtiInteraction): boolean {
-  return (
-    interaction.type === "graphicOrder" ||
-    interaction.type === "graphicAssociate" ||
-    interaction.type === "graphicGapMatch" ||
-    interaction.type === "hotspot" ||
-    interaction.type === "selectPoint" ||
-    interaction.type === "positionObject" ||
-    interaction.type === "media" ||
-    interaction.type === "drawing"
-  );
-}
-
-function hasRequiredObjectAsset(interaction: QtiInteraction): boolean {
-  if (interaction.type === "media") {
-    return Boolean(
-      interaction.object?.data || interaction.object?.sources.some((source) => Boolean(source.src)),
-    );
-  }
-  if (interaction.type === "drawing") return Boolean(interaction.object?.data);
-  return Boolean(interaction.object?.data);
-}
-
-function requireInteractionAttribute(
-  interaction: QtiInteraction,
-  attribute: string,
-  code: string,
-  diagnostics: QtiDiagnostic[],
-): void {
-  if (interaction.attributes[attribute]) return;
-  diagnostics.push({
-    code,
-    severity: "error",
-    message: `${interaction.qtiName} requires ${attribute}.`,
-    path: interaction.source?.path,
-    source: interaction.source,
-  });
-}
-
-function validatePortableCustomInteraction(
-  interaction: QtiInteraction,
-  item: QtiAssessmentItem,
-  diagnostics: QtiDiagnostic[],
-): void {
-  if (interaction.type !== "portableCustom") return;
-  const definition = interaction.portableCustom;
-  if (!definition) return;
-
-  const configuredModules = definition.interactionModules?.modules ?? [];
-  const hasModuleAttribute = Boolean(definition.module?.trim());
-  const hasConfiguredModule = configuredModules.some((module) => Boolean(module.id?.trim()));
-  if (!hasModuleAttribute && !hasConfiguredModule) {
-    diagnostics.push({
-      code: "interaction.portableCustom.module",
-      severity: "error",
-      message: `${interaction.qtiName} requires a module attribute or at least one qti-interaction-module id.`,
-      path: interaction.source?.path,
-      source: interaction.source,
-    });
-  }
-
-  for (const module of configuredModules) {
-    if (!module.id?.trim()) {
-      diagnostics.push({
-        code: "interaction.portableCustom.moduleId",
-        severity: "error",
-        message: "qti-interaction-module requires a non-empty id.",
-        path: module.source?.path,
-        source: module.source,
-      });
-    }
-    warnExternalPortableCustomUrl(module.primaryPath, module.source, diagnostics);
-    warnExternalPortableCustomUrl(module.fallbackPath, module.source, diagnostics);
-  }
-
-  warnExternalPortableCustomUrl(
-    definition.interactionModules?.primaryConfiguration,
-    definition.interactionModules?.source,
-    diagnostics,
-  );
-  warnExternalPortableCustomUrl(
-    definition.interactionModules?.secondaryConfiguration,
-    definition.interactionModules?.source,
-    diagnostics,
-  );
-
-  const templateIdentifiers = new Set(
-    item.templateDeclarations.map((declaration) => declaration.identifier),
-  );
-  for (const variable of definition.templateVariables) {
-    if (!variable.identifier?.trim()) {
-      diagnostics.push({
-        code: "interaction.portableCustom.templateVariable",
-        severity: "error",
-        message: "qti-template-variable requires template-identifier or identifier.",
-        path: variable.source?.path,
-        source: variable.source,
-      });
-      continue;
-    }
-    if (!templateIdentifiers.has(variable.identifier)) {
-      diagnostics.push({
-        code: "interaction.portableCustom.templateVariable.reference",
-        severity: "error",
-        message: `qti-template-variable references missing template declaration ${variable.identifier}.`,
-        path: variable.source?.path,
-        source: variable.source,
-      });
-    }
-  }
-
-  for (const variable of definition.contextVariables) {
-    if (variable.identifier?.trim()) continue;
-    diagnostics.push({
-      code: "interaction.portableCustom.contextVariable",
-      severity: "error",
-      message: "qti-context-variable requires identifier.",
-      path: variable.source?.path,
-      source: variable.source,
-    });
-  }
-
-  for (const stylesheet of definition.stylesheets) {
-    if (stylesheet.href.trim().length > 0) continue;
-    diagnostics.push({
-      code: "stylesheet.href.required",
-      severity: "error",
-      message: "qti-stylesheet requires a non-empty href attribute.",
-      path: stylesheet.source?.path,
-      source: stylesheet.source,
-    });
-  }
-}
-
-function warnExternalPortableCustomUrl(
-  url: string | undefined,
-  source: QtiDiagnostic["source"],
-  diagnostics: QtiDiagnostic[],
-): void {
-  if (!url || !/^https?:\/\//i.test(url)) return;
-  diagnostics.push({
-    code: "interaction.portableCustom.externalModuleUrl",
-    severity: "warning",
-    message: `Portable custom interaction module URL ${url} requires host delivery policy approval.`,
-    path: source?.path,
-    source,
-  });
-}
-
-function invalidNumber(
-  interaction: QtiInteraction,
-  attribute: string,
-  value: string,
-  diagnostics: QtiDiagnostic[],
-): void {
-  diagnostics.push({
-    code: "interaction.numericAttribute",
-    severity: "error",
-    message: `${interaction.qtiName} requires numeric ${attribute}, got ${value}.`,
-    path: interaction.source?.path,
-    source: interaction.source,
-  });
-}
-
-function validatePatternMaskAttribute(
-  interaction: QtiInteraction,
-  diagnostics: QtiDiagnostic[],
-): void {
-  if (interaction.type !== "textEntry" && interaction.type !== "extendedText") return;
-  const patternMask = interaction.attributes["pattern-mask"];
-  if (patternMask === undefined || isValidQtiPatternMask(patternMask)) return;
-  diagnostics.push({
-    code: "interaction.patternMask.invalid",
-    severity: "error",
-    message: `${interaction.qtiName} pattern-mask is not a valid regular expression.`,
-    path: interaction.source?.path,
-    source: interaction.source,
-  });
-}
-
-function validateInteractionLimitAttributes(
-  interaction: QtiInteraction,
-  diagnostics: QtiDiagnostic[],
-): void {
-  validateNonNegativeIntegerAttribute(interaction, "max-choices", diagnostics);
-  validateNonNegativeIntegerAttribute(interaction, "min-choices", diagnostics);
-  validateNonNegativeIntegerAttribute(interaction, "max-associations", diagnostics);
-  validateNonNegativeIntegerAttribute(interaction, "min-associations", diagnostics);
-  validateNonNegativeIntegerAttribute(interaction, "expected-length", diagnostics);
-  validateNonNegativeIntegerAttribute(interaction, "expected-lines", diagnostics);
-
-  validateMinMaxPair(interaction, "min-choices", "max-choices", diagnostics);
-  validateMinMaxPair(interaction, "min-associations", "max-associations", diagnostics);
-  if (interaction.type === "media") {
-    validateNonNegativeIntegerAttribute(interaction, "max-plays", diagnostics);
-    validateNonNegativeIntegerAttribute(interaction, "min-plays", diagnostics);
-    validateBooleanAttribute(interaction, "autostart", diagnostics);
-    validateBooleanAttribute(interaction, "loop", diagnostics);
-    validateMinMaxPair(interaction, "min-plays", "max-plays", diagnostics);
-  }
-}
-
-function validateChoiceLimitAttributes(choice: QtiChoice, diagnostics: QtiDiagnostic[]): void {
-  if (requiresMatchMax(choice) && !choice.attributes["match-max"]) {
-    diagnostics.push({
-      code: "choice.matchMax.required",
-      severity: "error",
-      message: `${choice.qtiName} ${choice.identifier} requires match-max.`,
-      path: choice.source?.path,
-      source: choice.source,
-    });
-  }
-
-  validateChoiceNonNegativeIntegerAttribute(choice, "match-max", diagnostics);
-  validateChoiceNonNegativeIntegerAttribute(choice, "match-min", diagnostics);
-  validateChoiceMinMaxPair(choice, "match-min", "match-max", diagnostics);
-  validateGapImageAsset(choice, diagnostics);
-  validateHotspotGeometry(choice, diagnostics);
-}
-
-function validateGapImageAsset(choice: QtiChoice, diagnostics: QtiDiagnostic[]): void {
-  if (choice.qtiName !== "qti-gap-img" || choice.asset?.data) return;
-  diagnostics.push({
-    code: "choice.gapImg.media.required",
-    severity: "error",
-    message: `qti-gap-img ${choice.identifier} requires an img, object, or picture child with a usable src or data attribute.`,
-    path: choice.source?.path,
-    source: choice.source,
-  });
-}
-
-function requiresMatchMax(choice: QtiChoice): boolean {
-  return (
-    choice.qtiName === "qti-simple-associable-choice" ||
-    choice.qtiName === "qti-associable-hotspot" ||
-    choice.qtiName === "qti-gap-text" ||
-    choice.qtiName === "qti-gap-img"
-  );
-}
-
-function validateHotspotGeometry(choice: QtiChoice, diagnostics: QtiDiagnostic[]): void {
-  if (choice.qtiName !== "qti-hotspot-choice" && choice.qtiName !== "qti-associable-hotspot") {
-    return;
-  }
-
-  const shape = choice.attributes.shape;
-  const coords = choice.attributes.coords;
-  if (!shape) {
-    diagnostics.push({
-      code: "choice.shape.required",
-      severity: "error",
-      message: `${choice.qtiName} ${choice.identifier} requires shape.`,
-      path: choice.source?.path,
-      source: choice.source,
-    });
-  } else if (!isHotspotShape(shape)) {
-    diagnostics.push({
-      code: "choice.shape",
-      severity: "error",
-      message: `${choice.qtiName} ${choice.identifier} has unsupported shape ${shape}.`,
-      path: choice.source?.path,
-      source: choice.source,
-    });
-  }
-
-  if (!coords) {
-    diagnostics.push({
-      code: "choice.coords.required",
-      severity: "error",
-      message: `${choice.qtiName} ${choice.identifier} requires coords.`,
-      path: choice.source?.path,
-      source: choice.source,
-    });
-    return;
-  }
-
-  const values = coords.split(",").map((value) => value.trim());
-  if (values.length === 0 || values.some((value) => value.length === 0 || !isFiniteNumber(value))) {
-    diagnostics.push({
-      code: "choice.coords",
-      severity: "error",
-      message: `${choice.qtiName} ${choice.identifier} requires comma-separated numeric coords.`,
-      path: choice.source?.path,
-      source: choice.source,
-    });
-    return;
-  }
-
-  if (shape && isHotspotShape(shape) && !hasValidShapeCoordinateCount(shape, values.map(Number))) {
-    diagnostics.push({
-      code: "choice.coords.shape",
-      severity: "error",
-      message: `${choice.qtiName} ${choice.identifier} shape ${shape} has invalid coords arity.`,
-      path: choice.source?.path,
-      source: choice.source,
-    });
-  }
-}
-
-function validateGraphicHotspotObjectDimensions(
-  interaction: QtiInteraction,
-  diagnostics: QtiDiagnostic[],
-): void {
-  if (!usesGraphicHotspots(interaction)) return;
-  const hotspotChoices = interaction.choices.filter(isHotspotChoice);
-  if (hotspotChoices.length === 0) return;
-
-  const width = positiveDimension(interaction.object?.width);
-  const height = positiveDimension(interaction.object?.height);
-  if (width === undefined || height === undefined) {
-    diagnostics.push({
-      code: "interaction.graphicObjectDimensions",
-      severity: "warning",
-      message: `${interaction.qtiName} should declare object width and height so hotspot coords map to the rendered image.`,
-      path: interaction.object?.source?.path ?? interaction.source?.path,
-      source: interaction.object?.source ?? interaction.source,
-    });
-    return;
-  }
-
-  for (const choice of hotspotChoices) {
-    const bounds = hotspotBounds(choice);
-    if (!bounds) continue;
-    if (bounds.left >= 0 && bounds.top >= 0 && bounds.right <= width && bounds.bottom <= height) {
-      continue;
-    }
-    diagnostics.push({
-      code: "choice.coords.bounds",
-      severity: "warning",
-      message: `${choice.qtiName} ${choice.identifier} coords extend outside the ${width} by ${height} object image.`,
-      path: choice.source?.path,
-      source: choice.source,
-    });
-  }
-}
-
-function usesGraphicHotspots(interaction: QtiInteraction): boolean {
-  return (
-    interaction.type === "graphicOrder" ||
-    interaction.type === "graphicAssociate" ||
-    interaction.type === "graphicGapMatch" ||
-    interaction.type === "hotspot"
-  );
-}
-
-function isHotspotChoice(choice: QtiChoice): boolean {
-  return choice.qtiName === "qti-hotspot-choice" || choice.qtiName === "qti-associable-hotspot";
-}
-
-function positiveDimension(value: string | undefined): number | undefined {
-  if (!value || value.trim().endsWith("%")) return undefined;
-  const match = value.trim().match(/^(\d+(?:\.\d+)?|\.\d+)(?:px)?$/i);
-  if (!match?.[1]) return undefined;
-  const parsed = Number(match[1]);
-  return Number.isFinite(parsed) && parsed > 0 ? parsed : undefined;
-}
-
-function hotspotBounds(
-  choice: QtiChoice,
-): { left: number; top: number; right: number; bottom: number } | undefined {
-  const shape = choice.attributes.shape;
-  const coords = choice.attributes.coords;
-  if (!shape || !coords || !isHotspotShape(shape) || !isNumericCsv(coords)) return undefined;
-  const values = numericCsv(coords);
-  if (!hasValidShapeCoordinateCount(shape, values)) return undefined;
-
-  if (shape === "default") return undefined;
-  if (shape === "circle") {
-    const [x, y, radius] = values as [number, number, number];
-    return { left: x - radius, top: y - radius, right: x + radius, bottom: y + radius };
-  }
-  if (shape === "ellipse") {
-    const [x, y, radiusX, radiusY] = values as [number, number, number, number];
-    return { left: x - radiusX, top: y - radiusY, right: x + radiusX, bottom: y + radiusY };
-  }
-  if (shape === "rect") {
-    const [left, top, right, bottom] = values as [number, number, number, number];
-    return { left, top, right, bottom };
-  }
-
-  const xs = values.filter((_, index) => index % 2 === 0);
-  const ys = values.filter((_, index) => index % 2 === 1);
-  return {
-    left: Math.min(...xs),
-    top: Math.min(...ys),
-    right: Math.max(...xs),
-    bottom: Math.max(...ys),
-  };
-}
-
-function isHotspotShape(value: string): boolean {
-  return (
-    value === "circle" ||
-    value === "default" ||
-    value === "ellipse" ||
-    value === "poly" ||
-    value === "rect"
-  );
-}
-
-function isAreaShape(value: string): boolean {
-  return value === "circle" || value === "default" || value === "poly" || value === "rect";
-}
-
-function isNumericCsv(value: string): boolean {
-  return value
-    .split(",")
-    .map((part) => part.trim())
-    .every((part) => part.length > 0 && isFiniteNumber(part));
-}
-
-function numericCsv(value: string): number[] {
-  return value.split(",").map((part) => Number(part.trim()));
-}
-
-function hasValidShapeCoordinateCount(shape: string, coords: number[]): boolean {
-  switch (shape) {
-    case "circle":
-      return coords.length === 3;
-    case "ellipse":
-    case "rect":
-      return coords.length === 4;
-    case "poly":
-      return coords.length >= 6 && coords.length % 2 === 0;
-    case "default":
-      return true;
-    default:
-      return false;
-  }
-}
-
-function validateNonNegativeIntegerAttribute(
-  interaction: QtiInteraction,
-  attribute: string,
-  diagnostics: QtiDiagnostic[],
-): void {
-  const value = interaction.attributes[attribute];
-  if (value === undefined || isNonNegativeInteger(value)) return;
-  diagnostics.push({
-    code: "interaction.integerAttribute",
-    severity: "error",
-    message: `${interaction.qtiName} requires non-negative integer ${attribute}, got ${value}.`,
-    path: interaction.source?.path,
-    source: interaction.source,
-  });
-}
-
-function validateBooleanAttribute(
-  interaction: QtiInteraction,
-  attribute: string,
-  diagnostics: QtiDiagnostic[],
-): void {
-  const value = interaction.attributes[attribute];
-  if (value === undefined || isBooleanAttribute(value)) return;
-  diagnostics.push({
-    code: "interaction.booleanAttribute",
-    severity: "error",
-    message: `${interaction.qtiName} requires boolean ${attribute}, got ${value}.`,
-    path: interaction.source?.path,
-    source: interaction.source,
-  });
-}
-
-function validateChoiceNonNegativeIntegerAttribute(
-  choice: QtiChoice,
-  attribute: string,
-  diagnostics: QtiDiagnostic[],
-): void {
-  const value = choice.attributes[attribute];
-  if (value === undefined || isNonNegativeInteger(value)) return;
-  diagnostics.push({
-    code: "choice.integerAttribute",
-    severity: "error",
-    message: `${choice.qtiName} ${choice.identifier} requires non-negative integer ${attribute}, got ${value}.`,
-    path: choice.source?.path,
-    source: choice.source,
-  });
-}
-
-function validateChoiceMinMaxPair(
-  choice: QtiChoice,
-  minAttribute: string,
-  maxAttribute: string,
-  diagnostics: QtiDiagnostic[],
-): void {
-  const min = choice.attributes[minAttribute];
-  const max = choice.attributes[maxAttribute];
-  if (
-    min === undefined ||
-    max === undefined ||
-    !isNonNegativeInteger(min) ||
-    !isNonNegativeInteger(max) ||
-    max === "0"
-  ) {
-    return;
-  }
-  if (Number(min) <= Number(max)) return;
-  diagnostics.push({
-    code: "choice.minMax",
-    severity: "error",
-    message: `${choice.qtiName} ${choice.identifier} requires ${minAttribute} to be less than or equal to ${maxAttribute}, unless ${maxAttribute} is 0 for unlimited.`,
-    path: choice.source?.path,
-    source: choice.source,
-  });
-}
-
-function validateMinMaxPair(
-  interaction: QtiInteraction,
-  minAttribute: string,
-  maxAttribute: string,
-  diagnostics: QtiDiagnostic[],
-): void {
-  const min = interaction.attributes[minAttribute];
-  const max = interaction.attributes[maxAttribute];
-  if (
-    min === undefined ||
-    max === undefined ||
-    !isNonNegativeInteger(min) ||
-    !isNonNegativeInteger(max) ||
-    max === "0"
-  ) {
-    return;
-  }
-  if (Number(min) <= Number(max)) return;
-  diagnostics.push({
-    code: "interaction.minMax",
-    severity: "error",
-    message: `${interaction.qtiName} requires ${minAttribute} to be less than or equal to ${maxAttribute}, unless ${maxAttribute} is 0 for unlimited.`,
-    path: interaction.source?.path,
-    source: interaction.source,
-  });
-}
-
-function allowedInteractionChildren(interaction: QtiInteraction): Set<string> | undefined {
-  const common = ["qti-prompt"];
-  switch (interaction.type) {
-    case "choice":
-      return setOf(common, ["qti-simple-choice"]);
-    case "order":
-      return setOf(common, ["qti-simple-choice"]);
-    case "associate":
-      return setOf(common, ["qti-simple-match-set", "qti-simple-associable-choice"]);
-    case "match":
-      return setOf(common, ["qti-simple-match-set"]);
-    case "gapMatch":
-      return setOf(common, ["qti-gap-text", "qti-gap-img", ...staticContentNames()]);
-    case "inlineChoice":
-      return setOf(common, ["qti-inline-choice"]);
-    case "hottext":
-      return setOf(common, staticContentNames());
-    case "graphicOrder":
-      return setOf(common, ["object", "qti-hotspot-choice"]);
-    case "graphicAssociate":
-      return setOf(common, ["object", "qti-associable-hotspot"]);
-    case "graphicGapMatch":
-      return setOf(common, [
-        "object",
-        "qti-gap-text",
-        "qti-gap-img",
-        "qti-associable-hotspot",
-        ...staticContentNames(),
-      ]);
-    case "hotspot":
-      return setOf(common, ["object", "qti-hotspot-choice"]);
-    case "positionObject":
-      return setOf(common, ["object", "img", "qti-position-object-stage"]);
-    case "selectPoint":
-    case "media":
-      return setOf(common, ["audio", "video", "object", "img"]);
-    case "drawing":
-      return setOf(common, ["object", "img", "picture"]);
-    case "extendedText":
-      return new Set(common);
-    case "portableCustom":
-      return setOf(common, [
-        "qti-interaction-markup",
-        "qti-interaction-modules",
-        "qti-template-variable",
-        "qti-context-variable",
-        "qti-stylesheet",
-        "qti-catalog-info",
-      ]);
-    case "slider":
-    case "textEntry":
-    case "upload":
-    case "endAttempt":
-      return new Set(common);
-    case "custom":
-      return undefined;
-  }
-}
-
-function staticContentNames(): string[] {
-  return ["p", "div", "span", "ul", "ol", "li", "table", "tbody", "thead", "tr", "td", "th"];
-}
-
-function setOf(...items: string[][]): Set<string> {
-  return new Set(items.flat());
-}
-
-function isCardinality(value: string): value is QtiCardinality {
-  return value === "single" || value === "multiple" || value === "ordered" || value === "record";
-}
-
-function isBaseType(value: string): value is QtiBaseType {
-  return (
-    value === "identifier" ||
-    value === "boolean" ||
-    value === "integer" ||
-    value === "float" ||
-    value === "string" ||
-    value === "point" ||
-    value === "pair" ||
-    value === "directedPair" ||
-    value === "duration" ||
-    value === "file" ||
-    value === "uri"
-  );
-}
-
-function isFiniteNumber(value: string): boolean {
-  return Number.isFinite(Number(value));
-}
-
-function isInteger(value: string): boolean {
-  return /^-?\d+$/.test(value);
-}
-
-function isNonNegativeInteger(value: string): boolean {
-  return /^\d+$/.test(value);
-}
-
-function isBooleanAttribute(value: string): boolean {
-  return value === "true" || value === "false" || value === "1" || value === "0";
-}
-
-function isPoint(value: string): boolean {
-  const parts = value.trim().split(/\s+/);
-  return parts.length === 2 && parts.every(isFiniteNumber);
-}
-
-function isPair(value: string): boolean {
-  const parts = value.trim().split(/\s+/);
-  return parts.length === 2 && parts.every((part) => part.length > 0);
-}
-
-function expectedResponseShape(
-  interaction: QtiInteraction,
-): { cardinalities: QtiCardinality[]; baseTypes: QtiBaseType[] } | undefined {
-  if (interaction.type === "endAttempt") {
-    return { cardinalities: ["single"], baseTypes: ["boolean"] };
-  }
-  if (interaction.type === "media") return { cardinalities: ["single"], baseTypes: ["integer"] };
-  if (interaction.type === "custom") return undefined;
-  if (interaction.type === "order" || interaction.type === "graphicOrder") {
-    return { cardinalities: ["ordered"], baseTypes: ["identifier"] };
-  }
-  if (interaction.type === "associate" || interaction.type === "graphicAssociate") {
-    return { cardinalities: ["multiple"], baseTypes: ["pair", "directedPair"] };
-  }
-  if (
-    interaction.type === "match" ||
-    interaction.type === "gapMatch" ||
-    interaction.type === "graphicGapMatch"
-  ) {
-    return { cardinalities: ["multiple"], baseTypes: ["directedPair"] };
-  }
-  if (interaction.type === "selectPoint" || interaction.type === "positionObject") {
-    return { cardinalities: ["single", "multiple"], baseTypes: ["point"] };
-  }
-  if (interaction.type === "slider") {
-    return { cardinalities: ["single"], baseTypes: ["integer", "float"] };
-  }
-  if (interaction.type === "upload") {
-    return { cardinalities: ["single"], baseTypes: ["file"] };
-  }
-  if (interaction.type === "textEntry" || interaction.type === "extendedText") {
-    return { cardinalities: ["single"], baseTypes: ["string"] };
-  }
-  if (interaction.type === "drawing") return { cardinalities: ["single"], baseTypes: ["file"] };
-  if (interaction.type === "portableCustom") {
-    return {
-      cardinalities: ["single", "multiple", "ordered", "record"],
-      baseTypes: [
-        "identifier",
-        "boolean",
-        "integer",
-        "float",
-        "string",
-        "point",
-        "pair",
-        "directedPair",
-        "duration",
-        "file",
-        "uri",
-      ],
-    };
-  }
-  return { cardinalities: ["single", "multiple"], baseTypes: ["identifier"] };
-}
-
-function needsChoices(interaction: QtiInteraction): boolean {
-  return (
-    interaction.type === "choice" ||
-    interaction.type === "order" ||
-    interaction.type === "associate" ||
-    interaction.type === "match" ||
-    interaction.type === "gapMatch" ||
-    interaction.type === "inlineChoice" ||
-    interaction.type === "hottext" ||
-    interaction.type === "graphicOrder" ||
-    interaction.type === "graphicAssociate" ||
-    interaction.type === "graphicGapMatch" ||
-    interaction.type === "hotspot"
-  );
 }