@longsightgroup/qti3-core 0.10.2 → 0.10.4

package/src/parser.ts

@@ -1,4 +1,4 @@
-import { appendContentTextNode, flatTextFromContent } from "./content-text.js";
+import { appendContentTextNode, flatTextFromContent, visibleTextContent } from "./content-text.js";
 import {
   parseOutcomeDeclaration,
   parseResponseDeclaration,
@@ -36,9 +36,9 @@ import type {
   QtiResponseDeclaration,
 } from "./types.js";
 import { validateAssessmentItem } from "./validation.js";
-import { childElements, descendants, parseXmlTree, textContent, type XmlNode } from "./xml.js";
+import { QTI_ASI_NAMESPACE } from "./qti-namespaces.js";
+import { childElements, descendants, parseXmlTree, type XmlNode } from "./xml.js";
 
-const qtiAssessmentItemNamespace = "http://www.imsglobal.org/xsd/imsqtiasi_v3p0";
 const supportedProcessingNames = new Set(processingSupport.map((entry) => entry.qtiName));
 const processingContainerNames = new Set(["qti-template-processing", "qti-response-processing"]);
 const responseProcessingForbiddenNames = new Set([
@@ -78,7 +78,7 @@ export function parseQtiXml(xml: string): QtiParseResult {
   }
 
   const itemNode =
-    tree.root.localName === "qti-assessment-item" && tree.root.uri === qtiAssessmentItemNamespace
+    tree.root.localName === "qti-assessment-item" && tree.root.uri === QTI_ASI_NAMESPACE
       ? tree.root
       : undefined;
   if (!itemNode) {
@@ -87,7 +87,7 @@ export function parseQtiXml(xml: string): QtiParseResult {
       severity: "error",
       message:
         tree.root.localName === "qti-assessment-item"
-          ? `Expected qti-assessment-item in namespace ${qtiAssessmentItemNamespace}, found ${tree.root.uri ?? "(none)"}.`
+          ? `Expected qti-assessment-item in namespace ${QTI_ASI_NAMESPACE}, found ${tree.root.uri ?? "(none)"}.`
           : `Expected qti-assessment-item root, found ${tree.root.localName}.`,
       path: tree.root.source.path,
       source: tree.root.source,
@@ -95,6 +95,23 @@ export function parseQtiXml(xml: string): QtiParseResult {
     return { ok: false, diagnostics };
   }
 
+  const foreignQtiElements = descendants(
+    itemNode,
+    (node) => node.localName.startsWith("qti-") && node.uri !== QTI_ASI_NAMESPACE,
+  );
+  if (foreignQtiElements.length > 0) {
+    for (const node of foreignQtiElements) {
+      diagnostics.push({
+        code: "qti.namespace",
+        severity: "error",
+        message: `Expected ${node.localName} in namespace ${QTI_ASI_NAMESPACE}, found ${node.uri ?? "(none)"}.`,
+        path: node.source.path,
+        source: node.source,
+      });
+    }
+    return { ok: false, diagnostics };
+  }
+
   const item = parseAssessmentItem(itemNode, diagnostics);
   const document: QtiDocument = { item, diagnostics };
   const validation = validateAssessmentItem(document);
@@ -109,16 +126,16 @@ export function parseQtiXml(xml: string): QtiParseResult {
 function parseAssessmentItem(node: XmlNode, diagnostics: QtiDiagnostic[]): QtiAssessmentItem {
   const identifier = node.attributes.identifier ?? "";
   const responseDeclarations = childElements(node, "qti-response-declaration").map(
-    parseResponseDeclaration,
+    (declarationNode) => parseResponseDeclaration(declarationNode, diagnostics),
   );
   const responseDeclarationMap = new Map(
     responseDeclarations.map((declaration) => [declaration.identifier, declaration]),
   );
   const outcomeDeclarations = childElements(node, "qti-outcome-declaration").map(
-    parseOutcomeDeclaration,
+    (declarationNode) => parseOutcomeDeclaration(declarationNode, diagnostics),
   );
   const templateDeclarations = childElements(node, "qti-template-declaration").map(
-    parseTemplateDeclaration,
+    (declarationNode) => parseTemplateDeclaration(declarationNode, diagnostics),
   );
   const templateProcessing = parseTemplateProcessing(
     childElements(node, "qti-template-processing")[0],
@@ -166,7 +183,7 @@ function parseAssessmentItem(node: XmlNode, diagnostics: QtiDiagnostic[]): QtiAs
     adaptive: parseXmlBoolean(node.attributes.adaptive) === true,
     timeDependent: parseXmlBoolean(node.attributes["time-dependent"]),
     attributes: node.attributes,
-    prompt: prompt ? textContent(prompt) : undefined,
+    prompt: prompt ? visibleTextContent(prompt) : undefined,
     itemBodyAttributes: itemBody?.attributes,
     itemBodySource: itemBody?.source,
     responseDeclarations,
@@ -181,7 +198,10 @@ function parseAssessmentItem(node: XmlNode, diagnostics: QtiDiagnostic[]): QtiAs
     catalogReferences,
     stylesheets,
     body,
-    bodyText: textContent(node),
+    bodyText: flatTextFromContent(body, {
+      excludeAnnotations: true,
+      interactionText: (interactionIndex) => interactions[interactionIndex]?.prompt ?? "",
+    }),
     source: node.source,
   };
 }
@@ -223,7 +243,18 @@ function diagnoseProcessingElements(
 }
 
 function isInteractionElement(node: XmlNode): boolean {
-  return interactionNameToType.has(node.localName) || /^qti-.+-interaction$/.test(node.localName);
+  return (
+    node.uri === QTI_ASI_NAMESPACE &&
+    (interactionNameToType.has(node.localName) || /^qti-.+-interaction$/.test(node.localName))
+  );
+}
+
+function isQtiElement(node: XmlNode, localName?: string): boolean {
+  return node.uri === QTI_ASI_NAMESPACE && (!localName || node.localName === localName);
+}
+
+function isQtiContentElement(node: XmlNode, localNames: ReadonlySet<string>): boolean {
+  return node.uri === QTI_ASI_NAMESPACE && localNames.has(node.localName);
 }
 
 function parseContentChildren(
@@ -262,7 +293,7 @@ function parseContentNode(
     };
   }
 
-  if (node.localName === "qti-printed-variable") {
+  if (isQtiElement(node, "qti-printed-variable")) {
     return {
       kind: "printedVariable",
       identifier: node.attributes.identifier ?? "",
@@ -272,7 +303,7 @@ function parseContentNode(
     };
   }
 
-  if (node.localName === "qti-feedback-block" || node.localName === "qti-feedback-inline") {
+  if (isQtiElement(node, "qti-feedback-block") || isQtiElement(node, "qti-feedback-inline")) {
     return {
       kind: "feedback",
       feedbackType: node.localName === "qti-feedback-block" ? "block" : "inline",
@@ -288,6 +319,7 @@ function parseContentNode(
   return {
     kind: "element",
     qtiName: node.localName,
+    namespaceUri: node.uri,
     attributes: node.attributes,
     children: parseContentChildren(node, diagnostics, responseDeclarationMap, interactions),
     source: node.source,
@@ -304,7 +336,7 @@ function parseInteraction(
   const responseDeclaration = responseIdentifier
     ? responseDeclarationMap.get(responseIdentifier)
     : undefined;
-  const prompt = childElements(node, "qti-prompt")[0];
+  const prompt = childElements(node, "qti-prompt").find((child) => isQtiElement(child));
   const registryStatus = interactionRegistryStatus(node.localName);
   diagnostics.push(...interactionRegistryDiagnostics(node.localName, node.source));
 
@@ -315,10 +347,7 @@ function parseInteraction(
         ? mediaInteractionObject(node)
         : interactionType === "drawing"
           ? drawingInteractionObject(node)
-          : descendants(
-              node,
-              (child) => child.localName === "object" || child.localName === "img",
-            )[0];
+          : descendants(node, (child) => isQtiContentElement(child, objectElementNames))[0];
 
   const promptContent = prompt
     ? parseContentChildren(prompt, diagnostics, responseDeclarationMap, [])
@@ -334,7 +363,7 @@ function parseInteraction(
     prompt: promptContent
       ? flatTextFromContent(promptContent, { excludeAnnotations: true }) || undefined
       : prompt
-        ? textContent(prompt)
+        ? visibleTextContent(prompt)
         : undefined,
     promptContent: promptContent && promptContent.length > 0 ? promptContent : undefined,
     promptAttributes: prompt?.attributes,
@@ -352,51 +381,42 @@ function parseInteraction(
       interactionType === "gapMatch" || interactionType === "graphicGapMatch"
         ? parseGapMatchSegments(node)
         : undefined,
-    childElements: childElements(node).map((child) => ({
-      qtiName: child.localName,
-      source: child.source,
-    })),
+    childElements: childElements(node)
+      .filter((child) => isQtiElement(child))
+      .map((child) => ({
+        qtiName: child.localName,
+        source: child.source,
+      })),
     attributes: node.attributes,
-    text: textContent(node),
+    text: visibleTextContent(node),
     source: node.source,
   };
 }
 
 function positionObjectInteractionObject(node: XmlNode): XmlNode | undefined {
-  return childElements(node).find(
-    (child) => child.localName === "object" || child.localName === "img",
-  );
+  return childElements(node).find((child) => isQtiContentElement(child, objectElementNames));
 }
 
 function mediaInteractionObject(node: XmlNode): XmlNode | undefined {
-  return childElements(node).find(
-    (child) =>
-      child.localName === "audio" ||
-      child.localName === "video" ||
-      child.localName === "object" ||
-      child.localName === "img",
-  );
+  return childElements(node).find((child) => isQtiContentElement(child, mediaElementNames));
 }
 
 function drawingInteractionObject(node: XmlNode): XmlNode | undefined {
-  return childElements(node).find(
-    (child) =>
-      child.localName === "object" || child.localName === "img" || child.localName === "picture",
-  );
+  return childElements(node).find((child) => isQtiContentElement(child, drawingElementNames));
 }
 
 function positionObjectStageObject(node: XmlNode): XmlNode | undefined {
   const ancestorStage = nearestAncestor(node, "qti-position-object-stage");
-  const stage = ancestorStage ?? childElements(node, "qti-position-object-stage")[0];
+  const stage =
+    ancestorStage ??
+    childElements(node, "qti-position-object-stage").find((child) => isQtiElement(child));
   if (!stage) return undefined;
-  return childElements(stage).find(
-    (child) => child.localName === "object" || child.localName === "img",
-  );
+  return childElements(stage).find((child) => isQtiContentElement(child, objectElementNames));
 }
 
 function nearestAncestor(node: XmlNode, localName: string): XmlNode | undefined {
   for (let parent = node.parent; parent; parent = parent.parent) {
-    if (parent.localName === localName) return parent;
+    if (isQtiElement(parent, localName)) return parent;
   }
   return undefined;
 }
@@ -411,13 +431,13 @@ function parseHottextSegments(node: XmlNode): QtiInteraction["hottextSegments"]
       return;
     }
 
-    if (entry.localName === "qti-prompt") return;
+    if (isQtiElement(entry, "qti-prompt")) return;
 
-    if (entry.localName === "qti-hottext") {
+    if (isQtiElement(entry, "qti-hottext")) {
       segments.push({
         kind: "hottext",
         identifier: entry.attributes.identifier ?? "",
-        text: textContent(entry),
+        text: visibleTextContent(entry),
         attributes: entry.attributes,
         source: entry.source,
       });
@@ -425,7 +445,7 @@ function parseHottextSegments(node: XmlNode): QtiInteraction["hottextSegments"]
     }
 
     for (const child of entry.content) visit(child);
-    if (entry.localName === "p" || entry.localName === "div") {
+    if (isQtiContentElement(entry, blockBoundaryElementNames)) {
       segments.push({ kind: "text", text: " " });
     }
   };
@@ -444,11 +464,11 @@ function parseGapMatchSegments(node: XmlNode): QtiInteraction["gapMatchSegments"
       return;
     }
 
-    if (entry.localName === "qti-prompt") return;
-    if (entry.localName === "qti-gap-text" || entry.localName === "qti-gap-img") return;
-    if (entry.localName === "object" || entry.localName === "img") return;
+    if (isQtiElement(entry, "qti-prompt")) return;
+    if (isQtiElement(entry, "qti-gap-text") || isQtiElement(entry, "qti-gap-img")) return;
+    if (isQtiContentElement(entry, objectElementNames)) return;
 
-    if (entry.localName === "qti-gap") {
+    if (isQtiElement(entry, "qti-gap")) {
       segments.push({
         kind: "gap",
         identifier: entry.attributes.identifier ?? "",
@@ -459,7 +479,7 @@ function parseGapMatchSegments(node: XmlNode): QtiInteraction["gapMatchSegments"
     }
 
     for (const child of entry.content) visit(child);
-    if (entry.localName === "p" || entry.localName === "div") {
+    if (isQtiContentElement(entry, blockBoundaryElementNames)) {
       segments.push({ kind: "text", text: " " });
     }
   };
@@ -475,7 +495,7 @@ function inlineInteractionContext(
   if (interactionType !== "inlineChoice" && interactionType !== "textEntry") return undefined;
   const parent = node.parent;
   if (!parent) return undefined;
-  return normalizeInlineContext(parent.text) ?? normalizeInlineContext(textContent(parent));
+  return normalizeInlineContext(parent.text) ?? normalizeInlineContext(visibleTextContent(parent));
 }
 
 function normalizeInlineContext(value: string): string | undefined {
@@ -488,7 +508,10 @@ function normalizeInlineContext(value: string): string | undefined {
 
 function parseObjectAsset(node: XmlNode | undefined): QtiObjectAsset | undefined {
   if (!node) return undefined;
-  const pictureImage = node.localName === "picture" ? childElements(node, "img")[0] : undefined;
+  const pictureImage =
+    node.localName === "picture"
+      ? childElements(node, "img").find((child) => isQtiElement(child))
+      : undefined;
   const data = node.attributes.data ?? node.attributes.src ?? pictureImage?.attributes.src;
   const sources = parseMediaSources(node);
   const tracks = parseMediaTracks(node);
@@ -505,7 +528,7 @@ function parseObjectAsset(node: XmlNode | undefined): QtiObjectAsset | undefined
       node.attributes.height ?? pictureImage?.attributes.height ?? inferredSvgDimensions?.height,
     sources,
     tracks,
-    text: textContent(node) || node.attributes.alt || pictureImage?.attributes.alt || "",
+    text: visibleTextContent(node) || node.attributes.alt || pictureImage?.attributes.alt || "",
     attributes: node.attributes,
     source: node.source,
   };
@@ -596,27 +619,31 @@ function formatDimension(value: number): string {
 }
 
 function parseMediaSources(node: XmlNode): QtiMediaSource[] {
-  return childElements(node, "source").map((source) => {
-    const src = source.attributes.src ?? firstSrcsetCandidate(source.attributes.srcset);
-    return {
-      src,
-      type: source.attributes.type ?? assetTypeFromData(src),
-      attributes: source.attributes,
-      source: source.source,
-    };
-  });
+  return childElements(node, "source")
+    .filter((source) => isQtiElement(source))
+    .map((source) => {
+      const src = source.attributes.src ?? firstSrcsetCandidate(source.attributes.srcset);
+      return {
+        src,
+        type: source.attributes.type ?? assetTypeFromData(src),
+        attributes: source.attributes,
+        source: source.source,
+      };
+    });
 }
 
 function parseMediaTracks(node: XmlNode): QtiObjectAsset["tracks"] {
-  return childElements(node, "track").map((track) => ({
-    kind: track.attributes.kind,
-    src: track.attributes.src,
-    srclang: track.attributes.srclang,
-    label: track.attributes.label,
-    default: track.attributes.default !== undefined,
-    attributes: track.attributes,
-    source: track.source,
-  }));
+  return childElements(node, "track")
+    .filter((track) => isQtiElement(track))
+    .map((track) => ({
+      kind: track.attributes.kind,
+      src: track.attributes.src,
+      srclang: track.attributes.srclang,
+      label: track.attributes.label,
+      default: track.attributes.default !== undefined,
+      attributes: track.attributes,
+      source: track.source,
+    }));
 }
 
 function firstSourceType(sources: QtiMediaSource[]): string | undefined {
@@ -663,37 +690,38 @@ function parseChoices(
     "qti-gap",
   ]);
 
-  return descendants(node, (child) => choiceNames.has(child.localName)).map((choice, index) => {
-    const identifier = choice.attributes.identifier ?? "";
-    const asset = parseChoiceAsset(choice);
-    const content = parseContentChildren(choice, diagnostics, responseDeclarationMap, []);
-    const flatChoiceText =
-      content.length > 0
-        ? flatTextFromContent(content, { excludeAnnotations: true })
-        : textContent(choice);
-    return {
-      identifier,
-      text:
-        flatChoiceText ||
-        choice.attributes["object-label"] ||
-        asset?.text ||
-        identifier ||
-        `Choice ${index + 1}`,
-      content: content.length > 0 ? content : undefined,
-      asset,
-      role: choiceRole(choice),
-      qtiName: choice.localName,
-      attributes: choice.attributes,
-      source: choice.source,
-    };
-  });
+  return descendants(node, (child) => isQtiContentElement(child, choiceNames)).map(
+    (choice, index) => {
+      const identifier = choice.attributes.identifier ?? "";
+      const asset = parseChoiceAsset(choice);
+      const content = parseContentChildren(choice, diagnostics, responseDeclarationMap, []);
+      const flatChoiceText =
+        content.length > 0
+          ? flatTextFromContent(content, { excludeAnnotations: true })
+          : visibleTextContent(choice);
+      return {
+        identifier,
+        text:
+          flatChoiceText ||
+          choice.attributes["object-label"] ||
+          asset?.text ||
+          identifier ||
+          `Choice ${index + 1}`,
+        content: content.length > 0 ? content : undefined,
+        asset,
+        role: choiceRole(choice),
+        qtiName: choice.localName,
+        attributes: choice.attributes,
+        source: choice.source,
+      };
+    },
+  );
 }
 
 function parseChoiceAsset(choice: XmlNode): QtiObjectAsset | undefined {
   if (choice.localName !== "qti-gap-img") return undefined;
-  const assetNode = childElements(choice).find(
-    (child) =>
-      child.localName === "img" || child.localName === "object" || child.localName === "picture",
+  const assetNode = childElements(choice).find((child) =>
+    isQtiContentElement(child, drawingElementNames),
   );
   return parseObjectAsset(assetNode);
 }
@@ -708,7 +736,8 @@ function choiceRole(node: XmlNode): QtiChoiceRole {
     return "hotspot";
   }
   if (node.localName === "qti-simple-associable-choice") {
-    const matchSet = node.parent?.localName === "qti-simple-match-set" ? node.parent : undefined;
+    const matchSet =
+      node.parent && isQtiElement(node.parent, "qti-simple-match-set") ? node.parent : undefined;
     const interaction = nearestInteraction(node);
     if (matchSet && interaction?.localName === "qti-match-interaction") {
       return matchSetIndex(matchSet) === 0 ? "matchSource" : "matchTarget";
@@ -720,13 +749,18 @@ function choiceRole(node: XmlNode): QtiChoiceRole {
 
 function nearestInteraction(node: XmlNode): XmlNode | undefined {
   for (let parent = node.parent; parent; parent = parent.parent) {
-    if (interactionNameToType.has(parent.localName)) return parent;
+    if (isQtiElement(parent) && interactionNameToType.has(parent.localName)) return parent;
   }
   return undefined;
 }
 
 function matchSetIndex(node: XmlNode): number {
   const siblings =
-    node.parent?.children.filter((sibling) => sibling.localName === "qti-simple-match-set") ?? [];
+    node.parent?.children.filter((sibling) => isQtiElement(sibling, "qti-simple-match-set")) ?? [];
   return siblings.indexOf(node);
 }
+
+const objectElementNames = new Set(["object", "img"]);
+const mediaElementNames = new Set(["audio", "video", ...objectElementNames]);
+const drawingElementNames = new Set(["picture", ...objectElementNames]);
+const blockBoundaryElementNames = new Set(["p", "div"]);

package/src/processing-evaluator-collection.ts

@@ -1,6 +1,7 @@
 import type { QtiProcessingExpression, QtiScalarValue, QtiValue } from "./types.js";
 import { assertNever } from "./assert-never.js";
 import type { EvaluationContext } from "./processing-evaluator.js";
+import { MAX_QTI_REPEAT_RESULT_ELEMENTS } from "./processing-limits.js";
 import { valueContainer } from "./processing-values.js";
 
 type CollectionExpression = Extract<
@@ -39,11 +40,15 @@ export function evaluateRepeatExpression(
   context: EvaluationContext,
 ): QtiValue {
   const repeats = context.indexValue(expression.numberRepeats);
-  if (repeats === undefined || repeats < 1) return null;
+  if (repeats === undefined || repeats < 1 || repeats > MAX_QTI_REPEAT_RESULT_ELEMENTS) {
+    return null;
+  }
   const container: QtiScalarValue[] = [];
   for (let repeat = 0; repeat < repeats; repeat += 1) {
     for (const item of expression.expressions) {
-      container.push(...valueContainer(context.evaluate(item)));
+      const values = valueContainer(context.evaluate(item));
+      if (values.length > MAX_QTI_REPEAT_RESULT_ELEMENTS - container.length) return null;
+      for (const value of values) container.push(value);
     }
   }
   return container.length > 0 ? container : null;

package/src/processing-evaluator-comparison.ts

@@ -9,7 +9,7 @@ import {
   valuesEqual,
   valueContainer,
 } from "./processing-values.js";
-import { expressionIsOrdered } from "./processing-variables.js";
+import { expressionBaseType, expressionIsOrdered } from "./processing-variables.js";
 import { roundWithMode } from "./processing-operators.js";
 
 type ComparisonExpression = Extract<
@@ -40,14 +40,30 @@ export function evaluateComparisonExpression(
         right,
         expressionIsOrdered(expression.left, context.document) ||
           expressionIsOrdered(expression.right, context.document),
+        expressionBaseType(expression.left, context.document) ??
+          expressionBaseType(expression.right, context.document),
       );
     }
     case "equal": {
       const left = context.evaluate(expression.left);
       const right = context.evaluate(expression.right);
-      return left === null || right === null ? null : valuesEqual(left, right);
+      return left === null || right === null
+        ? null
+        : valuesEqual(
+            left,
+            right,
+            false,
+            expressionBaseType(expression.left, context.document) ??
+              expressionBaseType(expression.right, context.document),
+          );
     }
     case "equalRounded": {
+      const validRounding =
+        Number.isInteger(expression.figures) &&
+        (expression.roundingMode === "decimalPlaces"
+          ? expression.figures >= 0
+          : expression.roundingMode === "significantFigures" && expression.figures > 0);
+      if (!validRounding) return null;
       const left = context.evaluate(expression.left);
       const right = context.evaluate(expression.right);
       if (left === null || right === null) return null;
@@ -80,7 +96,10 @@ export function evaluateComparisonExpression(
       const value = context.evaluate(expression.value);
       const collection = context.evaluate(expression.collection);
       if (value === null || collection === null) return null;
-      return valueContainer(collection).some((item) => valuesEqual(item, value));
+      const baseType =
+        expressionBaseType(expression.value, context.document) ??
+        expressionBaseType(expression.collection, context.document);
+      return valueContainer(collection).some((item) => valuesEqual(item, value, false, baseType));
     }
     case "delete": {
       const value = context.evaluate(expression.value);
@@ -88,7 +107,10 @@ export function evaluateComparisonExpression(
       if (value === null || collectionValue === null) return null;
       const collection = valueContainer(collectionValue);
       if (collection.length === 0) return null;
-      const filtered = collection.filter((item) => !valuesEqual(item, value));
+      const baseType =
+        expressionBaseType(expression.value, context.document) ??
+        expressionBaseType(expression.collection, context.document);
+      const filtered = collection.filter((item) => !valuesEqual(item, value, false, baseType));
       return filtered.length > 0 ? filtered : null;
     }
     case "contains": {
@@ -98,7 +120,10 @@ export function evaluateComparisonExpression(
       const collection = valueContainer(collectionValue);
       const values = valueContainer(valuesValue);
       if (collection.length === 0 || values.length === 0) return null;
-      return containsValues(collection, values);
+      const baseType =
+        expressionBaseType(expression.collection, context.document) ??
+        expressionBaseType(expression.values, context.document);
+      return containsValues(collection, values, baseType);
     }
     default:
       return assertNever(expression);

package/src/processing-evaluator-numeric.ts

@@ -47,10 +47,12 @@ export function evaluateNumericExpression(
 ): QtiValue {
   switch (expression.type) {
     case "sum": {
+      if (expression.expressions.length === 0) return null;
       const values = context.numericOperands(expression.expressions);
       return values ? values.reduce((sum, value) => sum + value, 0) : null;
     }
     case "product": {
+      if (expression.expressions.length === 0) return null;
       const values = context.numericOperands(expression.expressions);
       return values ? values.reduce((product, value) => product * value, 1) : null;
     }
@@ -127,7 +129,9 @@ export function evaluateNumericExpression(
       return mathOperatorValue(expression.name, values.map(numericValue));
     }
     case "statsOperator": {
-      const value = context.evaluate(expression.expression);
+      const expressions = expression.expressions ?? [expression.expression];
+      if (expressions.length !== 1) return null;
+      const value = context.evaluate(expressions[0]!);
       if (value === null) return null;
       return statsOperatorValue(expression.name, valueContainer(value).map(numericValue));
     }

package/src/processing-evaluator-variable.ts

@@ -37,6 +37,7 @@ export function evaluateVariableExpression(
             context.responses[expression.identifier] ?? null,
             context.correctResponses[expression.correctIdentifier] ?? null,
             declaration.cardinality === "ordered",
+            declaration.baseType,
           )
         : false;
     }

package/src/processing-expression-children.ts

@@ -43,8 +43,9 @@ export function expressionChildren(expression: QtiProcessingExpression): QtiProc
     case "patternMatch":
     case "fieldValue":
     case "inside":
-    case "statsOperator":
       return [expression.expression];
+    case "statsOperator":
+      return expression.expressions ?? [expression.expression];
     case "member":
     case "delete":
       return [expression.value, expression.collection];

package/src/processing-limits.ts

@@ -0,0 +1,2 @@
+/** Maximum scalar elements a single qti-repeat expression may produce. */
+export const MAX_QTI_REPEAT_RESULT_ELEMENTS = 10_000;