@longsightgroup/qti3-core 0.10.2 → 0.10.4

package/src/processing-mapping.ts

@@ -1,4 +1,5 @@
 import type { QtiDocument, QtiResponseDeclaration, QtiValue } from "./types.js";
+import { parseQtiPair } from "./parser-values.js";
 import { qtiScalarToString, qtiValueToStringList } from "./value-format.js";
 import { isRecordValue, numericValue, valuesEqual } from "./processing-values.js";
 
@@ -36,8 +37,15 @@ export function mapOrMatchResponse(
   correctResponse: QtiValue,
 ): number {
   if (declaration.areaMapping) return scoreAreaMapping(response, declaration.areaMapping);
-  if (declaration.mapping) return scoreMapping(response, declaration.mapping);
-  return valuesEqual(response, correctResponse, declaration.cardinality === "ordered") ? 1 : 0;
+  if (declaration.mapping) return scoreMapping(response, declaration.mapping, declaration.baseType);
+  return valuesEqual(
+    response,
+    correctResponse,
+    declaration.cardinality === "ordered",
+    declaration.baseType,
+  )
+    ? 1
+    : 0;
 }
 
 export function scoreAreaMapping(
@@ -49,6 +57,7 @@ export function scoreAreaMapping(
     : response === null
       ? []
       : qtiValueToStringList(response);
+  const matchedAreaIndexes = new Set<number>();
   let score = 0;
   for (const point of points) {
     const parsed = parsePoint(point);
@@ -56,8 +65,15 @@ export function scoreAreaMapping(
       score += areaMapping.defaultValue;
       continue;
     }
-    const entry = areaMapping.entries.find((candidate) => pointInsideArea(parsed, candidate));
-    score += entry?.mappedValue ?? areaMapping.defaultValue;
+    let matchedArea = false;
+    for (const [index, entry] of areaMapping.entries.entries()) {
+      if (!pointInsideArea(parsed, entry)) continue;
+      matchedArea = true;
+      if (matchedAreaIndexes.has(index)) continue;
+      matchedAreaIndexes.add(index);
+      score += entry.mappedValue;
+    }
+    if (!matchedArea) score += areaMapping.defaultValue;
   }
   return clampMappedScore(score, areaMapping.attributes);
 }
@@ -117,15 +133,17 @@ function pointInsidePolygon(point: { x: number; y: number }, coords: number[]):
 function scoreMapping(
   response: QtiValue,
   mapping: NonNullable<QtiResponseDeclaration["mapping"]>,
+  baseType: QtiResponseDeclaration["baseType"],
 ): number {
-  const values = Object.fromEntries(
+  const values = new Map(
     mapping.entries
       .filter((entry) => entry.mapKey !== undefined)
-      .map((entry) => [entry.mapKey!, entry.mappedValue]),
+      .map((entry) => [mappingKey(entry.mapKey!, baseType), entry.mappedValue] as const),
   );
   if (Array.isArray(response)) {
     const score = response.reduce<number>(
-      (sum, value) => sum + (values[String(value)] ?? mapping.defaultValue),
+      (sum, value) =>
+        sum + (values.get(mappingKey(String(value), baseType)) ?? mapping.defaultValue),
       0,
     );
     return clampMappedScore(score, mapping.attributes);
@@ -133,10 +151,16 @@ function scoreMapping(
   const score =
     response === null || isRecordValue(response)
       ? 0
-      : (values[String(response)] ?? mapping.defaultValue);
+      : (values.get(mappingKey(String(response), baseType)) ?? mapping.defaultValue);
   return clampMappedScore(score, mapping.attributes);
 }
 
+function mappingKey(value: string, baseType: QtiResponseDeclaration["baseType"]): string {
+  return baseType === "pair" || baseType === "directedPair"
+    ? (parseQtiPair(value, baseType) ?? value)
+    : value;
+}
+
 function clampMappedScore(score: number, attributes: Record<string, string>): number {
   const lower = numericBound(attributes["lower-bound"]);
   const upper = numericBound(attributes["upper-bound"]);

package/src/processing-operators.ts

@@ -39,15 +39,45 @@ export const STATS_OPERATOR_NAMES = [
   "popSD",
 ] as const;
 
+/** Round decimal ties away from zero without an intermediate scaled binary float. */
 export function roundToDecimalPlaces(value: number, figures: number): number {
-  const factor = 10 ** figures;
-  return Math.round(value * factor) / factor;
+  if (!Number.isFinite(value) || value === 0) return value;
+  const decimal = decimalDigits(value);
+  const retainedDigits = decimal.exponent + figures + 1;
+  return roundDecimalDigits(value, decimal, retainedDigits);
 }
 
+/** Round significant decimal digits, with half-up ties on the absolute magnitude. */
 export function roundToSignificantFigures(value: number, figures: number): number {
   if (value === 0 || figures <= 0) return 0;
-  const factor = 10 ** (figures - 1 - Math.floor(Math.log10(Math.abs(value))));
-  return Math.round(value * factor) / factor;
+  if (!Number.isFinite(value)) return Number.NaN;
+  return roundDecimalDigits(value, decimalDigits(value), figures);
+}
+
+interface DecimalDigits {
+  digits: string;
+  exponent: number;
+}
+
+function decimalDigits(value: number): DecimalDigits {
+  const [coefficient = "", exponent = "0"] = Math.abs(value).toExponential().split("e");
+  return {
+    digits: coefficient.replace(".", ""),
+    exponent: Number(exponent),
+  };
+}
+
+function roundDecimalDigits(value: number, decimal: DecimalDigits, retainedDigits: number): number {
+  if (retainedDigits >= decimal.digits.length) return value;
+  if (retainedDigits < 0) return value < 0 ? -0 : 0;
+
+  const roundingDigit = decimal.digits[retainedDigits] ?? "0";
+  const retained = retainedDigits === 0 ? 0n : BigInt(decimal.digits.slice(0, retainedDigits));
+  const rounded = roundingDigit >= "5" ? retained + 1n : retained;
+  if (rounded === 0n) return value < 0 ? -0 : 0;
+
+  const unitExponent = decimal.exponent - retainedDigits + 1;
+  return Number(`${value < 0 ? "-" : ""}${rounded}e${unitExponent}`);
 }
 
 export function roundWithMode(value: number, roundingMode: string, figures: number): number | null {
@@ -151,7 +181,10 @@ export function mathOperatorValue(name: string, values: number[]): QtiValue {
 }
 
 export function statsOperatorValue(name: string, values: number[]): QtiValue {
-  if (values.length === 0) return 0;
+  // QTI 3.0.1 defines the input as a numeric container but does not define empty-container
+  // results, so this implementation conservatively returns NULL.
+  // https://www.imsglobal.org/sites/default/files/spec/qti/v3/info/index.html#OpStatsOp
+  if (values.length === 0) return null;
   const meanValue = mean(values);
   const squareDiffs = values.map((value) => (value - meanValue) ** 2);
   switch (name) {

package/src/processing-values.ts

@@ -1,18 +1,32 @@
-import type { QtiRecordValue, QtiResponseDeclaration, QtiScalarValue, QtiValue } from "./types.js";
+import { parseQtiPair } from "./parser-values.js";
+import type {
+  QtiBaseType,
+  QtiRecordValue,
+  QtiResponseDeclaration,
+  QtiScalarValue,
+  QtiValue,
+} from "./types.js";
 import { qtiValueToString } from "./value-format.js";
 
 export function isNullResponse(response: QtiValue): boolean {
   return response === null || response === "" || (Array.isArray(response) && response.length === 0);
 }
 
-export function valuesEqual(actual: QtiValue, expected: QtiValue, ordered = false): boolean {
+export function valuesEqual(
+  actual: QtiValue,
+  expected: QtiValue,
+  ordered = false,
+  baseType?: QtiBaseType,
+): boolean {
   if (isRecordValue(actual) || isRecordValue(expected)) {
     if (!isRecordValue(actual) || !isRecordValue(expected)) return false;
     const actualKeys = Object.keys(actual).toSorted();
     const expectedKeys = Object.keys(expected).toSorted();
     return (
       valuesEqual(actualKeys, expectedKeys, true) &&
-      actualKeys.every((key) => valuesEqual(actual[key] ?? null, expected[key] ?? null, ordered))
+      actualKeys.every((key) =>
+        valuesEqual(actual[key] ?? null, expected[key] ?? null, ordered, baseType),
+      )
     );
   }
   if (Array.isArray(actual) || Array.isArray(expected)) {
@@ -20,25 +34,38 @@ export function valuesEqual(actual: QtiValue, expected: QtiValue, ordered = fals
     const expectedValues = Array.isArray(expected) ? expected : expected === null ? [] : [expected];
     if (actualValues.length !== expectedValues.length) return false;
     if (ordered)
-      return actualValues.every((value, index) => scalarValuesEqual(value, expectedValues[index]!));
-    const sortedExpected = [...expectedValues].toSorted(compareScalarValues);
+      return actualValues.every((value, index) =>
+        scalarValuesEqual(value, expectedValues[index]!, baseType),
+      );
+    const compareValues = (left: QtiScalarValue, right: QtiScalarValue): number =>
+      compareScalarValues(left, right, baseType);
+    const sortedExpected = [...expectedValues].toSorted(compareValues);
     return [...actualValues]
-      .toSorted(compareScalarValues)
-      .every((value, index) => scalarValuesEqual(value, sortedExpected[index]!));
+      .toSorted(compareValues)
+      .every((value, index) => scalarValuesEqual(value, sortedExpected[index]!, baseType));
   }
-  return scalarValuesEqual(actual, expected);
+  return scalarValuesEqual(actual, expected, baseType);
 }
 
 export function qtiMatchValues(
   actual: QtiValue,
   expected: QtiValue,
   ordered = false,
+  baseType?: QtiBaseType,
 ): boolean | null {
   if (actual === null || expected === null) return null;
-  return valuesEqual(actual, expected, ordered);
+  return valuesEqual(actual, expected, ordered, baseType);
 }
 
-function scalarValuesEqual(actual: QtiValue, expected: QtiValue): boolean {
+function scalarValuesEqual(actual: QtiValue, expected: QtiValue, baseType?: QtiBaseType): boolean {
+  if (
+    (baseType === "pair" || baseType === "directedPair") &&
+    typeof actual === "string" &&
+    typeof expected === "string"
+  ) {
+    const normalizedActual = parseQtiPair(actual, baseType);
+    return normalizedActual !== undefined && normalizedActual === parseQtiPair(expected, baseType);
+  }
   if (typeof actual === "boolean" && typeof expected === "string") {
     return String(actual) === expected;
   }
@@ -79,18 +106,36 @@ export function isRecordValue(value: QtiValue): value is QtiRecordValue {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
-export function containsValues(collection: QtiScalarValue[], values: QtiScalarValue[]): boolean {
+export function containsValues(
+  collection: QtiScalarValue[],
+  values: QtiScalarValue[],
+  baseType?: QtiBaseType,
+): boolean {
   const remaining = [...collection];
   for (const value of values) {
-    const index = remaining.findIndex((candidate) => valuesEqual(candidate, value));
+    const index = remaining.findIndex((candidate) =>
+      valuesEqual(candidate, value, false, baseType),
+    );
     if (index === -1) return false;
     remaining.splice(index, 1);
   }
   return true;
 }
 
-function compareScalarValues(left: QtiScalarValue, right: QtiScalarValue): number {
-  return String(left).localeCompare(String(right));
+function compareScalarValues(
+  left: QtiScalarValue,
+  right: QtiScalarValue,
+  baseType?: QtiBaseType,
+): number {
+  const leftKey =
+    (baseType === "pair" || baseType === "directedPair") && typeof left === "string"
+      ? (parseQtiPair(left, baseType) ?? left)
+      : String(left);
+  const rightKey =
+    (baseType === "pair" || baseType === "directedPair") && typeof right === "string"
+      ? (parseQtiPair(right, baseType) ?? right)
+      : String(right);
+  return leftKey.localeCompare(rightKey);
 }
 
 export function numericValue(value: QtiValue): number {

package/src/processing-variables.ts

@@ -1,4 +1,5 @@
 import type {
+  QtiBaseType,
   QtiDocument,
   QtiOutcomeDeclaration,
   QtiProcessingExpression,
@@ -6,6 +7,7 @@ import type {
   QtiTemplateDeclaration,
   QtiValue,
 } from "./types.js";
+import { parseBaseType } from "./parser-values.js";
 
 export function getResponseDeclaration(
   document: QtiDocument,
@@ -51,11 +53,11 @@ export function expressionIsOrdered(
   document: QtiDocument,
 ): boolean {
   if (expression.type === "ordered") return true;
+  if (expression.type === "delete") return expressionIsOrdered(expression.collection, document);
   if (
     (expression.type === "variable" ||
       expression.type === "correct" ||
-      expression.type === "default" ||
-      expression.type === "isNull") &&
+      expression.type === "default") &&
     variableCardinality(document, expression.identifier) === "ordered"
   ) {
     return true;
@@ -63,6 +65,49 @@ export function expressionIsOrdered(
   return false;
 }
 
+/** Resolve the declared atomic base type for an expression when it is statically knowable. */
+export function expressionBaseType(
+  expression: QtiProcessingExpression,
+  document: QtiDocument,
+): QtiBaseType | undefined {
+  if (expression.type === "baseValue") return parseBaseType(expression.baseType);
+  if (expression.type === "isNull") return "boolean";
+  if (
+    expression.type === "variable" ||
+    expression.type === "correct" ||
+    expression.type === "default"
+  ) {
+    return resolveVariableDeclaration(document, expression.identifier)?.baseType;
+  }
+  if (expression.type === "index") return expressionBaseType(expression.expression, document);
+  if (expression.type === "delete") return expressionBaseType(expression.collection, document);
+  if (
+    expression.type === "random" ||
+    expression.type === "multiple" ||
+    expression.type === "ordered" ||
+    expression.type === "repeat"
+  ) {
+    return commonExpressionBaseType(
+      expression.type === "random" ? expression.values : expression.expressions,
+      document,
+    );
+  }
+  return undefined;
+}
+
+function commonExpressionBaseType(
+  expressions: QtiProcessingExpression[],
+  document: QtiDocument,
+): QtiBaseType | undefined {
+  const [first, ...rest] = expressions;
+  if (!first) return undefined;
+  const baseType = expressionBaseType(first, document);
+  if (!baseType) return undefined;
+  return rest.every((expression) => expressionBaseType(expression, document) === baseType)
+    ? baseType
+    : undefined;
+}
+
 function variableCardinality(document: QtiDocument, identifier: string): string | undefined {
   return resolveVariableDeclaration(document, identifier)?.cardinality;
 }

package/src/qti-namespaces.ts

@@ -0,0 +1,8 @@
+/** Namespace for QTI 3 assessment, section, and item documents. */
+export const QTI_ASI_NAMESPACE = "http://www.imsglobal.org/xsd/imsqtiasi_v3p0";
+
+/** Namespace for MathML embedded in QTI content. */
+export const MATHML_NAMESPACE = "http://www.w3.org/1998/Math/MathML";
+
+/** Namespace for QTI 3 content-package manifests. */
+export const QTI_PACKAGE_MANIFEST_NAMESPACE = "http://www.imsglobal.org/xsd/qti/qtiv3p0/imscp_v1p1";

package/src/qti-package-items.ts

@@ -34,6 +34,7 @@ import {
 } from "./qti-package-xml.js";
 import type { QtiPackageEntry } from "./qti-package-zip.js";
 import type { QtiDiagnostic } from "./types.js";
+import { QTI_ASI_NAMESPACE } from "./qti-namespaces.js";
 
 export interface PackageItemReference {
   readonly href: string;
@@ -83,13 +84,18 @@ export function parseAssessmentTestPackageModel(
   const xmlFile = xmlFilesByPath.get(href) ?? parsePackageXml(entry);
   const testDiagnostics: QtiDiagnostic[] = [];
   pushXmlDiagnostics(xmlFile, testDiagnostics);
-  const root = xmlFile.root?.localName === "qti-assessment-test" ? xmlFile.root : undefined;
+  const root =
+    xmlFile.root?.localName === "qti-assessment-test" && xmlFile.root.uri === QTI_ASI_NAMESPACE
+      ? xmlFile.root
+      : undefined;
   if (xmlFile.root && !root) {
     pushPackageDiagnostic(
       testDiagnostics,
       "package.assessmentTest.root",
       "error",
-      `Expected qti-assessment-test root, found ${xmlFile.root.localName}.`,
+      xmlFile.root.localName === "qti-assessment-test"
+        ? `Expected qti-assessment-test in namespace ${QTI_ASI_NAMESPACE}, found ${xmlFile.root.uri ?? "(none)"}.`
+        : `Expected qti-assessment-test root, found ${xmlFile.root.localName}.`,
       href,
     );
   }
@@ -98,7 +104,7 @@ export function parseAssessmentTestPackageModel(
   const itemRefs = testParts.flatMap(flattenTestPartItemRefs);
   const assetHrefs = root ? discoverContentAssetHrefs(xmlFile, testDiagnostics) : [];
   const timeLimits = root
-    ? parseTimeLimits(childPackageElements(root, "qti-time-limits")[0], href, testDiagnostics)
+    ? parseTimeLimits(qtiChildElements(root, "qti-time-limits")[0], href, testDiagnostics)
     : undefined;
   const timing = root ? parseTimingMetadata(root, href, testDiagnostics, timeLimits) : undefined;
   const scopedDiagnostics = testDiagnostics.map((diagnostic) =>
@@ -128,18 +134,18 @@ function parseAssessmentTestParts(
   sourcePath: string,
   diagnostics: QtiDiagnostic[],
 ): QtiTestPartPackageModel[] {
-  return childPackageElements(root, "qti-test-part").map((partNode) => {
+  return qtiChildElements(root, "qti-test-part").map((partNode) => {
     const identifier = partNode.attributes.identifier ?? "";
     return {
       identifier,
       navigationMode: parseNavigationMode(partNode, sourcePath, diagnostics),
       submissionMode: parseSubmissionMode(partNode, sourcePath, diagnostics),
       timeLimits: parseTimeLimits(
-        childPackageElements(partNode, "qti-time-limits")[0],
+        qtiChildElements(partNode, "qti-time-limits")[0],
         sourcePath,
         diagnostics,
       ),
-      sections: childPackageElements(partNode, "qti-assessment-section").map((sectionNode) =>
+      sections: qtiChildElements(partNode, "qti-assessment-section").map((sectionNode) =>
         parseAssessmentSection(sectionNode, identifier, undefined, sourcePath, diagnostics),
       ),
       attributes: { ...partNode.attributes },
@@ -156,43 +162,41 @@ function parseAssessmentSection(
 ): QtiAssessmentSectionPackageModel {
   const identifier = sectionNode.attributes.identifier ?? "";
   const visible = parseOptionalXmlBoolean(sectionNode, "visible", sourcePath, diagnostics);
-  const itemRefs = childPackageElements(sectionNode, "qti-assessment-item-ref").flatMap(
-    (refNode) => {
-      const rawHref = refNode.attributes.href;
-      if (!rawHref) {
-        pushPackageDiagnostic(
+  const itemRefs = qtiChildElements(sectionNode, "qti-assessment-item-ref").flatMap((refNode) => {
+    const rawHref = refNode.attributes.href;
+    if (!rawHref) {
+      pushPackageDiagnostic(
+        diagnostics,
+        "package.assessmentTest.itemRef.href.missing",
+        "error",
+        "qti-assessment-item-ref is missing href.",
+        sourcePath,
+      );
+      return [];
+    }
+
+    const href = resolvePackageHref(sourcePath, rawHref, diagnostics);
+    if (!href) return [];
+    return [
+      {
+        identifier: refNode.attributes.identifier,
+        href,
+        testPartIdentifier,
+        sectionIdentifier: identifier,
+        timeLimits: parseTimeLimits(
+          qtiChildElements(refNode, "qti-time-limits")[0],
+          sourcePath,
           diagnostics,
-          "package.assessmentTest.itemRef.href.missing",
-          "error",
-          "qti-assessment-item-ref is missing href.",
+        ),
+        itemSessionControl: parseItemSessionControl(
+          qtiChildElements(refNode, "qti-item-session-control")[0],
           sourcePath,
-        );
-        return [];
-      }
-
-      const href = resolvePackageHref(sourcePath, rawHref, diagnostics);
-      if (!href) return [];
-      return [
-        {
-          identifier: refNode.attributes.identifier,
-          href,
-          testPartIdentifier,
-          sectionIdentifier: identifier,
-          timeLimits: parseTimeLimits(
-            childPackageElements(refNode, "qti-time-limits")[0],
-            sourcePath,
-            diagnostics,
-          ),
-          itemSessionControl: parseItemSessionControl(
-            childPackageElements(refNode, "qti-item-session-control")[0],
-            sourcePath,
-            diagnostics,
-          ),
-          attributes: { ...refNode.attributes },
-        },
-      ];
-    },
-  );
+          diagnostics,
+        ),
+        attributes: { ...refNode.attributes },
+      },
+    ];
+  });
 
   return {
     identifier,
@@ -201,12 +205,12 @@ function parseAssessmentSection(
     testPartIdentifier,
     parentSectionIdentifier,
     timeLimits: parseTimeLimits(
-      childPackageElements(sectionNode, "qti-time-limits")[0],
+      qtiChildElements(sectionNode, "qti-time-limits")[0],
       sourcePath,
       diagnostics,
     ),
     itemRefs,
-    sections: childPackageElements(sectionNode, "qti-assessment-section").map((child) =>
+    sections: qtiChildElements(sectionNode, "qti-assessment-section").map((child) =>
       parseAssessmentSection(child, testPartIdentifier, identifier, sourcePath, diagnostics),
     ),
     attributes: { ...sectionNode.attributes },
@@ -385,14 +389,13 @@ export function parsePackageItems(
     diagnostics.push(...itemDiagnostics);
 
     const assetHrefs = xmlFile.root ? discoverContentAssetHrefs(xmlFile, diagnostics) : [];
-    const root = xmlFile.root?.localName === "qti-assessment-item" ? xmlFile.root : undefined;
+    const root =
+      xmlFile.root?.localName === "qti-assessment-item" && xmlFile.root.uri === QTI_ASI_NAMESPACE
+        ? xmlFile.root
+        : undefined;
     const item = parsed.document?.item;
     const timeLimits = root
-      ? parseTimeLimits(
-          childPackageElements(root, "qti-time-limits")[0],
-          reference.href,
-          diagnostics,
-        )
+      ? parseTimeLimits(qtiChildElements(root, "qti-time-limits")[0], reference.href, diagnostics)
       : undefined;
 
     items.push({
@@ -421,3 +424,7 @@ export function parsePackageItems(
 
   return items;
 }
+
+function qtiChildElements(node: QtiPackageXmlNode, localName: string): QtiPackageXmlNode[] {
+  return childPackageElements(node, localName, QTI_ASI_NAMESPACE);
+}

package/src/qti-package-manifest.ts

@@ -5,6 +5,7 @@ import type { QtiManifestFile, QtiManifestResource, QtiPackageShape } from "./qt
 import { childPackageElements, packageDescendants, stripHrefSuffix } from "./qti-package-xml.js";
 import type { QtiPackageEntry } from "./qti-package-zip.js";
 import type { QtiDiagnostic } from "./types.js";
+import { QTI_PACKAGE_MANIFEST_NAMESPACE } from "./qti-namespaces.js";
 
 export const QTI_PACKAGE_MANIFEST_PATH = "imsmanifest.xml";
 
@@ -23,8 +24,12 @@ export function parseManifestResources(
   entriesByPath: ReadonlyMap<string, QtiPackageEntry>,
   diagnostics: QtiDiagnostic[],
 ): QtiManifestResource[] {
-  const resourceNodes = packageDescendants(manifestRoot, "resources").flatMap((resources) =>
-    childPackageElements(resources, "resource"),
+  const resourceNodes = packageDescendants(
+    manifestRoot,
+    "resources",
+    QTI_PACKAGE_MANIFEST_NAMESPACE,
+  ).flatMap((resources) =>
+    childPackageElements(resources, "resource", QTI_PACKAGE_MANIFEST_NAMESPACE),
   );
   const resources: QtiManifestResource[] = [];
 
@@ -71,7 +76,7 @@ function parseManifestFiles(
   diagnostics: QtiDiagnostic[],
 ): QtiManifestFile[] {
   const files: QtiManifestFile[] = [];
-  for (const fileNode of packageDescendants(resourceNode, "file")) {
+  for (const fileNode of packageDescendants(resourceNode, "file", QTI_PACKAGE_MANIFEST_NAMESPACE)) {
     const rawHref = fileNode.attributes.href;
     if (!rawHref) {
       pushPackageDiagnostic(
@@ -105,7 +110,11 @@ function parseManifestDependencies(
   diagnostics: QtiDiagnostic[],
 ): string[] {
   const dependencies: string[] = [];
-  for (const dependencyNode of packageDescendants(resourceNode, "dependency")) {
+  for (const dependencyNode of packageDescendants(
+    resourceNode,
+    "dependency",
+    QTI_PACKAGE_MANIFEST_NAMESPACE,
+  )) {
     const identifierref = dependencyNode.attributes.identifierref;
     if (!identifierref) {
       pushPackageDiagnostic(

package/src/qti-package-metadata.ts

@@ -11,6 +11,7 @@ import type {
   QtiTimingMetadata,
 } from "./qti-package-types.js";
 import type { QtiDiagnostic } from "./types.js";
+import { QTI_ASI_NAMESPACE, QTI_PACKAGE_MANIFEST_NAMESPACE } from "./qti-namespaces.js";
 
 /** Known QTI / IMS CP alignment element names plus attribute-driven manifest metadata. */
 const STANDARD_ALIGNMENT_ELEMENT_NAMES = new Set([
@@ -34,7 +35,7 @@ export function parseTimingMetadata(
   diagnostics: QtiDiagnostic[],
   parsedTimeLimits?: QtiTimeLimits,
 ): QtiTimingMetadata | undefined {
-  const timeLimitsNode = childPackageElements(root, "qti-time-limits")[0];
+  const timeLimitsNode = childPackageElements(root, "qti-time-limits", QTI_ASI_NAMESPACE)[0];
   const timeLimits = parsedTimeLimits ?? parseTimeLimits(timeLimitsNode, sourcePath, diagnostics);
   const timeDependent = parseXmlBoolean(root.attributes["time-dependent"]);
   if (!timeLimitsNode && timeDependent === undefined) return undefined;
@@ -296,7 +297,7 @@ export function packageTitle(
   items: readonly QtiPackageItem[],
 ): string {
   const manifestTitle = manifestRoot
-    ? packageDescendants(manifestRoot, "title")
+    ? packageDescendants(manifestRoot, "title", QTI_PACKAGE_MANIFEST_NAMESPACE)
         .map((node) => node.text.trim())
         .find((text) => text.length > 0)
     : undefined;

package/src/qti-package-xml.ts

@@ -39,22 +39,35 @@ export function pushXmlDiagnostics(xmlFile: PackageXmlFile, diagnostics: QtiDiag
   }
 }
 
+/** Return direct package-XML children, optionally restricted by local name and namespace. */
 export function childPackageElements(
   node: QtiPackageXmlNode,
   localName?: string,
+  namespaceUri?: string,
 ): QtiPackageXmlNode[] {
-  return node.children.filter((child) => !localName || child.localName === localName);
+  return node.children.filter(
+    (child) =>
+      (!localName || child.localName === localName) &&
+      (namespaceUri === undefined || child.uri === namespaceUri),
+  );
 }
 
+/** Return package-XML descendants, optionally restricted by local name and namespace. */
 export function packageDescendants(
   node: QtiPackageXmlNode | undefined,
   localName?: string,
+  namespaceUri?: string,
 ): QtiPackageXmlNode[] {
   if (!node) return [];
   const found: QtiPackageXmlNode[] = [];
   for (const child of node.children) {
-    if (!localName || child.localName === localName) found.push(child);
-    found.push(...packageDescendants(child, localName));
+    if (
+      (!localName || child.localName === localName) &&
+      (namespaceUri === undefined || child.uri === namespaceUri)
+    ) {
+      found.push(child);
+    }
+    found.push(...packageDescendants(child, localName, namespaceUri));
   }
   return found;
 }