@longsightgroup/qti3-core 0.10.1 → 0.10.3

package/src/support.ts

@@ -11,9 +11,14 @@ import type {
 import {
   browserFeedbackTests,
   browserHarnessTests,
+  coreIntegrationTest,
   interactionSupportFixtures,
   interactionSupportTests,
   processingBrowserEvidence,
+  processingMappingTest,
+  processingOperatorsTest,
+  processingResponseTest,
+  processingTemplateTest,
 } from "./support-evidence.js";
 
 export const interactionSupport: QtiInteractionElementSupport[] = [
@@ -52,15 +57,19 @@ export const deprecatedInteractionSupport: QtiInteractionElementSupport[] = [
     render: false,
     process: false,
     fixtures: [],
-    tests: ["packages/core/src/core.test.ts"],
+    tests: [coreIntegrationTest],
     notes: "Deprecated in favor of qti-portable-custom-interaction.",
   },
 ];
 
+const templateProcessingEntry = processingEntryFor(processingTemplateTest);
+const responseProcessingEntry = processingEntryFor(processingResponseTest);
+const mappingProcessingEntry = processingEntryFor(processingMappingTest);
+const operatorProcessingEntry = processingEntryFor(processingOperatorsTest);
+
 export const processingSupport: QtiProcessingElementSupport[] = [
-  processingEntry(
+  templateProcessingEntry(
     "qti-template-processing",
-    "packages/core/src/core.test.ts",
     [
       "packages/fixtures/xml/template-processing-reference.xml",
       "packages/fixtures/xml/random-integer-template-reference.xml",
@@ -68,9 +77,8 @@ export const processingSupport: QtiProcessingElementSupport[] = [
     ],
     [...processingBrowserEvidence["qti-template-processing"]],
   ),
-  processingEntry(
+  responseProcessingEntry(
     "qti-response-processing",
-    "packages/core/src/core.test.ts",
     [
       "packages/fixtures/xml/mapping-processing-reference.xml",
       "packages/fixtures/xml/generic-match-processing-reference.xml",
@@ -79,64 +87,64 @@ export const processingSupport: QtiProcessingElementSupport[] = [
     ],
     [...processingBrowserEvidence["qti-response-processing"]],
   ),
-  processingEntry("qti-set-template-value", "packages/core/src/core.test.ts", [
+  templateProcessingEntry("qti-set-template-value", [
     "packages/fixtures/xml/template-processing-reference.xml",
     "packages/fixtures/xml/random-integer-template-reference.xml",
     "packages/fixtures/xml/template-content-reference.xml",
   ]),
-  processingEntry("qti-set-default-value", "packages/core/src/core.test.ts"),
-  processingEntry("qti-set-correct-response", "packages/core/src/core.test.ts", [
+  templateProcessingEntry("qti-set-default-value"),
+  templateProcessingEntry("qti-set-correct-response", [
     "packages/fixtures/xml/template-processing-reference.xml",
     "packages/fixtures/xml/random-integer-template-reference.xml",
   ]),
-  processingEntry("qti-template-condition", "packages/core/src/core.test.ts"),
-  processingEntry("qti-template-if", "packages/core/src/core.test.ts"),
-  processingEntry("qti-template-else-if", "packages/core/src/core.test.ts"),
-  processingEntry("qti-template-else", "packages/core/src/core.test.ts"),
-  processingEntry("qti-template-constraint", "packages/core/src/core.test.ts"),
-  processingEntry("qti-response-condition", "packages/core/src/core.test.ts", [
+  templateProcessingEntry("qti-template-condition"),
+  templateProcessingEntry("qti-template-if"),
+  templateProcessingEntry("qti-template-else-if"),
+  templateProcessingEntry("qti-template-else"),
+  templateProcessingEntry("qti-template-constraint"),
+  responseProcessingEntry("qti-response-condition", [
     "packages/fixtures/xml/generic-match-processing-reference.xml",
     "packages/fixtures/xml/advanced-processing-reference.xml",
     "packages/fixtures/xml/adaptive-feedback-reference.xml",
   ]),
-  processingEntry("qti-response-if", "packages/core/src/core.test.ts", [
+  responseProcessingEntry("qti-response-if", [
     "packages/fixtures/xml/generic-match-processing-reference.xml",
     "packages/fixtures/xml/advanced-processing-reference.xml",
     "packages/fixtures/xml/adaptive-feedback-reference.xml",
   ]),
-  processingEntry("qti-response-else-if", "packages/core/src/core.test.ts"),
-  processingEntry("qti-response-else", "packages/core/src/core.test.ts", [
+  responseProcessingEntry("qti-response-else-if"),
+  responseProcessingEntry("qti-response-else", [
     "packages/fixtures/xml/generic-match-processing-reference.xml",
   ]),
-  processingEntry("qti-set-outcome-value", "packages/core/src/core.test.ts", [
+  responseProcessingEntry("qti-set-outcome-value", [
     "packages/fixtures/xml/generic-match-processing-reference.xml",
     "packages/fixtures/xml/advanced-processing-reference.xml",
     "packages/fixtures/xml/adaptive-feedback-reference.xml",
   ]),
-  processingEntry("qti-lookup-outcome-value", "packages/core/src/core.test.ts"),
-  processingEntry("qti-exit-response", "packages/core/src/core.test.ts"),
-  processingEntry("qti-exit-template", "packages/core/src/core.test.ts"),
-  processingEntry("qti-response-processing-fragment", "packages/core/src/core.test.ts"),
-  processingEntry("qti-base-value", "packages/core/src/core.test.ts", [
+  mappingProcessingEntry("qti-lookup-outcome-value"),
+  responseProcessingEntry("qti-exit-response"),
+  templateProcessingEntry("qti-exit-template"),
+  responseProcessingEntry("qti-response-processing-fragment"),
+  operatorProcessingEntry("qti-base-value", [
     "packages/fixtures/xml/generic-match-processing-reference.xml",
     "packages/fixtures/xml/template-processing-reference.xml",
     "packages/fixtures/xml/advanced-processing-reference.xml",
   ]),
-  processingEntry("qti-null", "packages/core/src/core.test.ts"),
-  processingEntry("qti-match-table", "packages/core/src/core.test.ts"),
-  processingEntry("qti-match-table-entry", "packages/core/src/core.test.ts"),
-  processingEntry("qti-interpolation-table", "packages/core/src/core.test.ts"),
-  processingEntry("qti-interpolation-table-entry", "packages/core/src/core.test.ts"),
-  processingEntry("qti-is-null", "packages/core/src/core.test.ts"),
-  processingEntry("qti-match", "packages/core/src/core.test.ts", [
+  operatorProcessingEntry("qti-null"),
+  mappingProcessingEntry("qti-match-table"),
+  mappingProcessingEntry("qti-match-table-entry"),
+  mappingProcessingEntry("qti-interpolation-table"),
+  mappingProcessingEntry("qti-interpolation-table-entry"),
+  operatorProcessingEntry("qti-is-null"),
+  mappingProcessingEntry("qti-match", [
     "packages/fixtures/xml/generic-match-processing-reference.xml",
     "packages/fixtures/xml/advanced-processing-reference.xml",
   ]),
-  processingEntry("qti-correct", "packages/core/src/core.test.ts"),
-  processingEntry("qti-default", "packages/core/src/core.test.ts"),
-  processingEntry("qti-map-response", "packages/core/src/core.test.ts"),
-  processingEntry("qti-map-response-point", "packages/core/src/core.test.ts"),
-  processingEntry("qti-variable", "packages/core/src/core.test.ts", [
+  mappingProcessingEntry("qti-correct"),
+  mappingProcessingEntry("qti-default"),
+  mappingProcessingEntry("qti-map-response"),
+  mappingProcessingEntry("qti-map-response-point"),
+  responseProcessingEntry("qti-variable", [
     "packages/fixtures/xml/generic-match-processing-reference.xml",
     "packages/fixtures/xml/template-processing-reference.xml",
     "packages/fixtures/xml/random-integer-template-reference.xml",
@@ -144,81 +152,74 @@ export const processingSupport: QtiProcessingElementSupport[] = [
     "packages/fixtures/xml/advanced-processing-reference.xml",
     "packages/fixtures/xml/adaptive-feedback-reference.xml",
   ]),
-  processingEntry(
+  templateProcessingEntry(
     "qti-random-integer",
-    "packages/core/src/core.test.ts",
     ["packages/fixtures/xml/random-integer-template-reference.xml"],
     [...processingBrowserEvidence["qti-random-integer"]],
   ),
-  processingEntry("qti-random-float", "packages/core/src/core.test.ts"),
-  processingEntry("qti-random", "packages/core/src/core.test.ts"),
-  processingEntry("qti-multiple", "packages/core/src/core.test.ts", [
+  operatorProcessingEntry("qti-random-float"),
+  operatorProcessingEntry("qti-random"),
+  operatorProcessingEntry("qti-multiple", [
     "packages/fixtures/xml/advanced-processing-reference.xml",
   ]),
-  processingEntry("qti-ordered", "packages/core/src/core.test.ts", [
+  operatorProcessingEntry("qti-ordered", [
     "packages/fixtures/xml/advanced-processing-reference.xml",
   ]),
-  processingEntry("qti-index", "packages/core/src/core.test.ts"),
-  processingEntry("qti-contains", "packages/core/src/core.test.ts"),
-  processingEntry("qti-container-size", "packages/core/src/core.test.ts", [
+  operatorProcessingEntry("qti-index"),
+  operatorProcessingEntry("qti-contains"),
+  operatorProcessingEntry("qti-container-size", [
     "packages/fixtures/xml/advanced-processing-reference.xml",
   ]),
-  processingEntry("qti-sum", "packages/core/src/core.test.ts", [
+  operatorProcessingEntry("qti-sum", [
     "packages/fixtures/xml/template-processing-reference.xml",
     "packages/fixtures/xml/random-integer-template-reference.xml",
   ]),
-  processingEntry("qti-product", "packages/core/src/core.test.ts", [
+  operatorProcessingEntry("qti-product", [
     "packages/fixtures/xml/random-integer-template-reference.xml",
   ]),
-  processingEntry("qti-min", "packages/core/src/core.test.ts"),
-  processingEntry("qti-max", "packages/core/src/core.test.ts"),
-  processingEntry("qti-subtract", "packages/core/src/core.test.ts"),
-  processingEntry("qti-divide", "packages/core/src/core.test.ts"),
-  processingEntry("qti-power", "packages/core/src/core.test.ts"),
-  processingEntry("qti-integer-divide", "packages/core/src/core.test.ts"),
-  processingEntry("qti-integer-modulus", "packages/core/src/core.test.ts"),
-  processingEntry("qti-round", "packages/core/src/core.test.ts"),
-  processingEntry("qti-round-to", "packages/core/src/core.test.ts"),
-  processingEntry("qti-truncate", "packages/core/src/core.test.ts"),
-  processingEntry("qti-integer-to-float", "packages/core/src/core.test.ts"),
-  processingEntry("qti-and", "packages/core/src/core.test.ts"),
-  processingEntry("qti-any-n", "packages/core/src/core.test.ts"),
-  processingEntry("qti-or", "packages/core/src/core.test.ts"),
-  processingEntry("qti-not", "packages/core/src/core.test.ts"),
-  processingEntry("qti-equal", "packages/core/src/core.test.ts"),
-  processingEntry("qti-equal-rounded", "packages/core/src/core.test.ts", [
-    "packages/fixtures/xml/advanced-processing-reference.xml",
-  ]),
-  processingEntry("qti-field-value", "packages/core/src/core.test.ts"),
-  processingEntry("qti-lt", "packages/core/src/core.test.ts"),
-  processingEntry("qti-lte", "packages/core/src/core.test.ts"),
-  processingEntry("qti-gt", "packages/core/src/core.test.ts"),
-  processingEntry("qti-gte", "packages/core/src/core.test.ts"),
-  processingEntry("qti-string-match", "packages/core/src/core.test.ts"),
-  processingEntry("qti-substring", "packages/core/src/core.test.ts"),
-  processingEntry("qti-pattern-match", "packages/core/src/core.test.ts"),
-  processingEntry("qti-member", "packages/core/src/core.test.ts"),
-  processingEntry("qti-delete", "packages/core/src/core.test.ts"),
-  processingEntry("qti-duration-gte", "packages/core/src/core.test.ts"),
-  processingEntry("qti-duration-lt", "packages/core/src/core.test.ts"),
-  processingEntry("qti-gcd", "packages/core/src/core.test.ts", [
-    "packages/fixtures/xml/advanced-processing-reference.xml",
-  ]),
-  processingEntry("qti-inside", "packages/core/src/core.test.ts", [
+  operatorProcessingEntry("qti-min"),
+  operatorProcessingEntry("qti-max"),
+  operatorProcessingEntry("qti-subtract"),
+  operatorProcessingEntry("qti-divide"),
+  operatorProcessingEntry("qti-power"),
+  operatorProcessingEntry("qti-integer-divide"),
+  operatorProcessingEntry("qti-integer-modulus"),
+  operatorProcessingEntry("qti-round"),
+  operatorProcessingEntry("qti-round-to"),
+  operatorProcessingEntry("qti-truncate"),
+  operatorProcessingEntry("qti-integer-to-float"),
+  operatorProcessingEntry("qti-and"),
+  operatorProcessingEntry("qti-any-n"),
+  operatorProcessingEntry("qti-or"),
+  operatorProcessingEntry("qti-not"),
+  operatorProcessingEntry("qti-equal"),
+  operatorProcessingEntry("qti-equal-rounded", [
     "packages/fixtures/xml/advanced-processing-reference.xml",
   ]),
-  processingEntry("qti-lcm", "packages/core/src/core.test.ts", [
+  mappingProcessingEntry("qti-field-value"),
+  operatorProcessingEntry("qti-lt"),
+  operatorProcessingEntry("qti-lte"),
+  operatorProcessingEntry("qti-gt"),
+  operatorProcessingEntry("qti-gte"),
+  operatorProcessingEntry("qti-string-match"),
+  operatorProcessingEntry("qti-substring"),
+  operatorProcessingEntry("qti-pattern-match"),
+  operatorProcessingEntry("qti-member"),
+  operatorProcessingEntry("qti-delete"),
+  operatorProcessingEntry("qti-duration-gte"),
+  operatorProcessingEntry("qti-duration-lt"),
+  operatorProcessingEntry("qti-gcd", ["packages/fixtures/xml/advanced-processing-reference.xml"]),
+  mappingProcessingEntry("qti-inside", ["packages/fixtures/xml/advanced-processing-reference.xml"]),
+  operatorProcessingEntry("qti-lcm", ["packages/fixtures/xml/advanced-processing-reference.xml"]),
+  operatorProcessingEntry("qti-math-constant"),
+  operatorProcessingEntry("qti-math-operator"),
+  operatorProcessingEntry("qti-repeat", [
     "packages/fixtures/xml/advanced-processing-reference.xml",
   ]),
-  processingEntry("qti-math-constant", "packages/core/src/core.test.ts"),
-  processingEntry("qti-math-operator", "packages/core/src/core.test.ts"),
-  processingEntry("qti-repeat", "packages/core/src/core.test.ts", [
+  operatorProcessingEntry("qti-stats-operator", [
     "packages/fixtures/xml/advanced-processing-reference.xml",
   ]),
-  processingEntry("qti-stats-operator", "packages/core/src/core.test.ts", [
-    "packages/fixtures/xml/advanced-processing-reference.xml",
-  ]),
-  processingEntry("qti-custom-operator", "packages/core/src/core.test.ts"),
+  operatorProcessingEntry("qti-custom-operator"),
 ];
 
 export const itemMetadataSupport: QtiItemMetadataElementSupport[] = [
@@ -234,11 +235,7 @@ export const itemMetadataSupport: QtiItemMetadataElementSupport[] = [
     fixtures: [
       "packages/fixtures/packages/basic-item-player/valid-item-only/items/tolerance-extra-features.xml",
     ],
-    tests: [
-      "packages/core/src/core.test.ts",
-      "packages/core/src/parser-item-metadata.test.ts",
-      ...browserHarnessTests,
-    ],
+    tests: ["packages/core/src/parser-item-metadata.test.ts", ...browserHarnessTests],
     notes:
       "Parsed by parser-item-metadata.ts and validated by validateCatalogInfo. Duplicate containers emit item.child.duplicate. Manual harness debugger coverage is in player-harness.spec.ts.",
   },
@@ -255,7 +252,6 @@ export const itemMetadataSupport: QtiItemMetadataElementSupport[] = [
       "packages/fixtures/packages/basic-item-player/valid-item-only/items/tolerance-extra-features.xml",
     ],
     tests: [
-      "packages/core/src/core.test.ts",
       "packages/core/src/parser-item-metadata.test.ts",
       "tests/browser/player-package.spec.ts",
       ...browserHarnessTests,
@@ -266,20 +262,20 @@ export const itemMetadataSupport: QtiItemMetadataElementSupport[] = [
   {
     qtiName: "qti-modal-feedback",
     category: "itemMetadata",
-    support: "parsed",
+    support: "rendered",
     specReference: "QTI 3.0.1 ASI",
     parse: true,
     validate: true,
-    render: false,
-    process: false,
+    render: true,
+    process: true,
     fixtures: ["packages/fixtures/src/index.ts"],
     tests: [
-      "packages/core/src/core.test.ts",
+      processingResponseTest,
       "packages/core/src/parser-item-metadata.test.ts",
       ...browserFeedbackTests,
     ],
     notes:
-      "Parsed by parser-item-metadata.ts and validated by validateModalFeedback. Player renders outcome-gated modal feedback in player-feedback.spec.ts.",
+      "Parsed by parser-item-metadata.ts and validated by validateModalFeedback. Response processing supplies the outcome value used for visibility, and the player renders the matching feedback in player-feedback.spec.ts.",
   },
   {
     qtiName: "qti-companion-materials-info",
@@ -430,9 +426,17 @@ function pciEntry(): QtiInteractionElementSupport {
   };
 }
 
+function processingEntryFor(coreTest: string) {
+  return (
+    qtiName: string,
+    fixtures: string[] = [],
+    extraTests: string[] = [],
+  ): QtiProcessingElementSupport => processingEntry(coreTest, qtiName, fixtures, extraTests);
+}
+
 function processingEntry(
+  coreTest: string,
   qtiName: string,
-  test: string,
   fixtures: string[] = [],
   extraTests: string[] = [],
 ): QtiProcessingElementSupport {
@@ -446,6 +450,6 @@ function processingEntry(
     render: false,
     process: true,
     fixtures,
-    tests: [test, ...extraTests],
+    tests: [coreTest, ...extraTests],
   };
 }

package/src/types.ts

@@ -687,7 +687,14 @@ export type QtiProcessingExpression = (
   | { type: "mathConstant"; name: string }
   | { type: "mathOperator"; name: string; expressions: QtiProcessingExpression[] }
   | { type: "repeat"; numberRepeats: string; expressions: QtiProcessingExpression[] }
-  | { type: "statsOperator"; name: string; expression: QtiProcessingExpression }
+  | {
+      type: "statsOperator";
+      name: string;
+      /** First child retained for compatibility with manually constructed expressions. */
+      expression: QtiProcessingExpression;
+      /** Authored children, including invalid zero- or multi-child forms, when parsed from XML. */
+      expressions?: QtiProcessingExpression[] | undefined;
+    }
   | {
       type: "customOperator";
       definition?: string | undefined;

package/src/validation-declaration-entries.ts

@@ -0,0 +1,162 @@
+import type { QtiDiagnostic, QtiLookupTable } from "./types.js";
+import {
+  hasValidShapeCoordinateCount,
+  isAreaShape,
+  isNumericCsv,
+  numericCsv,
+} from "./validation-geometry.js";
+import { isFiniteNumber, isInteger } from "./validation-primitives.js";
+
+interface DeclarationEntryAttributes {
+  attributes: Record<string, string>;
+  source?: QtiDiagnostic["source"] | undefined;
+}
+
+/** Append diagnostics for raw qti-map-entry attributes. */
+export function validateMapEntryAttributes(
+  declarationIdentifier: string,
+  entry: DeclarationEntryAttributes,
+  diagnostics: QtiDiagnostic[],
+): void {
+  if (!entry.attributes["map-key"]) {
+    diagnostics.push({
+      code: "mapEntry.mapKey.required",
+      severity: "error",
+      message: `Response declaration ${declarationIdentifier} map entry requires map-key.`,
+      path: entry.source?.path,
+      source: entry.source,
+    });
+  }
+
+  const mappedValue = entry.attributes["mapped-value"];
+  if (mappedValue === undefined) {
+    diagnostics.push({
+      code: "mapEntry.mappedValue.required",
+      severity: "error",
+      message: `Response declaration ${declarationIdentifier} map entry requires mapped-value.`,
+      path: entry.source?.path,
+      source: entry.source,
+    });
+  } else if (!isFiniteNumber(mappedValue)) {
+    diagnostics.push({
+      code: "mapEntry.mappedValue",
+      severity: "error",
+      message: `Response declaration ${declarationIdentifier} map entry requires numeric mapped-value.`,
+      path: entry.source?.path,
+      source: entry.source,
+    });
+  }
+}
+
+/** Append diagnostics for raw qti-area-map-entry attributes. */
+export function validateAreaMapEntryAttributes(
+  declarationIdentifier: string,
+  entry: DeclarationEntryAttributes,
+  diagnostics: QtiDiagnostic[],
+): void {
+  const shape = entry.attributes.shape;
+  const coords = entry.attributes.coords;
+  const mappedValue = entry.attributes["mapped-value"];
+
+  if (!shape) {
+    diagnostics.push({
+      code: "areaMapEntry.shape.required",
+      severity: "error",
+      message: `Response declaration ${declarationIdentifier} area map entry requires shape.`,
+      path: entry.source?.path,
+      source: entry.source,
+    });
+  } else if (!isAreaShape(shape)) {
+    diagnostics.push({
+      code: "areaMapEntry.shape",
+      severity: "error",
+      message: `Response declaration ${declarationIdentifier} area map entry has unsupported shape ${shape}.`,
+      path: entry.source?.path,
+      source: entry.source,
+    });
+  }
+
+  if (!coords) {
+    diagnostics.push({
+      code: "areaMapEntry.coords.required",
+      severity: "error",
+      message: `Response declaration ${declarationIdentifier} area map entry requires coords.`,
+      path: entry.source?.path,
+      source: entry.source,
+    });
+  } else if (!isNumericCsv(coords)) {
+    diagnostics.push({
+      code: "areaMapEntry.coords",
+      severity: "error",
+      message: `Response declaration ${declarationIdentifier} area map entry requires comma-separated numeric coords.`,
+      path: entry.source?.path,
+      source: entry.source,
+    });
+  } else if (
+    shape &&
+    isAreaShape(shape) &&
+    !hasValidShapeCoordinateCount(shape, numericCsv(coords))
+  ) {
+    diagnostics.push({
+      code: "areaMapEntry.coords.shape",
+      severity: "error",
+      message: `Response declaration ${declarationIdentifier} area map entry shape ${shape} has invalid coords arity.`,
+      path: entry.source?.path,
+      source: entry.source,
+    });
+  }
+
+  if (mappedValue === undefined) {
+    diagnostics.push({
+      code: "areaMapEntry.mappedValue.required",
+      severity: "error",
+      message: `Response declaration ${declarationIdentifier} area map entry requires mapped-value.`,
+      path: entry.source?.path,
+      source: entry.source,
+    });
+  } else if (!isFiniteNumber(mappedValue)) {
+    diagnostics.push({
+      code: "areaMapEntry.mappedValue",
+      severity: "error",
+      message: `Response declaration ${declarationIdentifier} area map entry requires numeric mapped-value.`,
+      path: entry.source?.path,
+      source: entry.source,
+    });
+  }
+}
+
+/** Append diagnostics for raw lookup-table entry attributes. */
+export function validateLookupTableEntryAttributes(
+  tableType: QtiLookupTable["type"],
+  entry: DeclarationEntryAttributes,
+  diagnostics: QtiDiagnostic[],
+): void {
+  const sourceValue = entry.attributes["source-value"];
+  if (sourceValue === undefined || !isFiniteNumber(sourceValue)) {
+    diagnostics.push({
+      code: "lookupTable.entry.sourceValue",
+      severity: "error",
+      message: "Lookup table entry requires numeric source-value.",
+      path: entry.source?.path,
+      source: entry.source,
+    });
+  }
+  if (entry.attributes["target-value"] === undefined) {
+    diagnostics.push({
+      code: "lookupTable.entry.targetValue",
+      severity: "error",
+      message: "Lookup table entry requires target-value.",
+      path: entry.source?.path,
+      source: entry.source,
+    });
+  }
+  if (tableType === "match" && sourceValue !== undefined && !isInteger(sourceValue)) {
+    diagnostics.push({
+      code: "lookupTable.match.sourceValue",
+      severity: "error",
+      message: "qti-match-table-entry source-value must be an integer.",
+      path: entry.source?.path,
+      source: entry.source,
+    });
+  }
+}

package/src/validation-interactions.ts

@@ -9,6 +9,8 @@ import type {
 } from "./types.js";
 import { assertNever } from "./assert-never.js";
 import { isValidQtiPatternMask } from "./pattern-mask.js";
+import { parseQtiMediaDefinition } from "./media-definition.js";
+import { parseQtiSliderDefinition } from "./slider-definition.js";
 import { validateInteractionSharedVocabulary } from "./shared-vocabulary-interaction-validation.js";
 import { qtiValueToStringList } from "./value-format.js";
 import {
@@ -17,7 +19,6 @@ import {
 } from "./validation-geometry.js";
 import {
   isBooleanAttribute,
-  isFiniteNumber,
   isNonNegativeInteger,
   requireIdentifier,
 } from "./validation-primitives.js";
@@ -104,7 +105,11 @@ function validateInteractionResponseShape(
     });
   }
 
-  if (interaction.responseBaseType && !expected.baseTypes.includes(interaction.responseBaseType)) {
+  if (
+    interaction.type !== "slider" &&
+    interaction.responseBaseType &&
+    !expected.baseTypes.includes(interaction.responseBaseType)
+  ) {
     diagnostics.push({
       code: "interaction.baseType",
       severity: "error",
@@ -305,46 +310,13 @@ function validateInteractionRequiredAttributes(
   }
 
   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);
-    }
+    const definition = parseQtiSliderDefinition(interaction);
+    if (!definition.ok) diagnostics.push(...definition.diagnostics);
+  }
+
+  if (interaction.type === "media") {
+    const definition = parseQtiMediaDefinition(interaction);
+    if (!definition.ok) diagnostics.push(...definition.diagnostics);
   }
 }
 
@@ -497,21 +469,6 @@ function warnExternalPortableCustomUrl(
   });
 }
 
-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[],
@@ -542,13 +499,6 @@ function validateInteractionLimitAttributes(
   validateMinMaxPair(interaction, "min-choices", "max-choices", diagnostics);
   validateMinMaxPair(interaction, "min-associations", "max-associations", diagnostics);
   validateBooleanAttribute(interaction, "required", 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 {

package/src/validation-primitives.ts

@@ -1,5 +1,5 @@
 import type { QtiBaseType, QtiCardinality, QtiDiagnostic } from "./types.js";
-import { parseXmlBoolean } from "./parser-values.js";
+import { parseFiniteNumber, parseXmlBoolean } from "./parser-values.js";
 
 export function requireIdentifier(
   qtiName: string,
@@ -38,7 +38,7 @@ export function isBaseType(value: string): value is QtiBaseType {
 }
 
 export function isFiniteNumber(value: string): boolean {
-  return Number.isFinite(Number(value));
+  return parseFiniteNumber(value) !== undefined;
 }
 
 export function isInteger(value: string): boolean {