@longsightgroup/qti3-core 0.10.6 → 0.12.0

package/src/processing-mapping.ts

@@ -1,7 +1,8 @@
 import type { QtiDocument, QtiResponseDeclaration, QtiValue } from "./types.js";
-import { parseQtiPair } from "./parser-values.js";
+import { parseQtiPair, parseXmlBoolean } from "./parser-values.js";
 import { qtiScalarToString, qtiValueToStringList } from "./value-format.js";
-import { isRecordValue, numericValue, valuesEqual } from "./processing-values.js";
+import { numericValue, valuesEqual } from "./processing-values.js";
+import { isRecordValue } from "./value-guards.js";
 
 export function lookupOutcomeValue(
   document: QtiDocument,
@@ -21,13 +22,11 @@ export function lookupOutcomeValue(
       lookupTable.defaultValue
     );
   }
-  const entry = [...lookupTable.entries]
-    .toSorted((left, right) => left.sourceValue - right.sourceValue)
-    .find(
-      (candidate) =>
-        numeric < candidate.sourceValue ||
-        (candidate.includeBoundary !== false && numeric === candidate.sourceValue),
-    );
+  const entry = lookupTable.entries.find(
+    (candidate) =>
+      numeric > candidate.sourceValue ||
+      (candidate.includeBoundary !== false && numeric === candidate.sourceValue),
+  );
   return entry?.targetValue ?? lookupTable.defaultValue;
 }
 
@@ -69,9 +68,12 @@ export function scoreAreaMapping(
     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 (!matchedAreaIndexes.has(index)) {
+        matchedAreaIndexes.add(index);
+        score += entry.mappedValue;
+      }
+      // Authored priority applies even when this area was already counted.
+      break;
     }
     if (!matchedArea) score += areaMapping.defaultValue;
   }
@@ -135,23 +137,27 @@ function scoreMapping(
   mapping: NonNullable<QtiResponseDeclaration["mapping"]>,
   baseType: QtiResponseDeclaration["baseType"],
 ): number {
-  const values = new Map(
-    mapping.entries
-      .filter((entry) => entry.mapKey !== undefined)
-      .map((entry) => [mappingKey(entry.mapKey!, baseType), entry.mappedValue] as const),
-  );
+  const mappedValue = (value: string): number => {
+    const key = mappingKey(value, baseType);
+    const entry = mapping.entries.find((candidate) => {
+      if (candidate.mapKey === undefined) return false;
+      const candidateKey = mappingKey(candidate.mapKey, baseType);
+      const caseSensitive = parseXmlBoolean(candidate.attributes["case-sensitive"]) ?? false;
+      return baseType === "string" && !caseSensitive
+        ? candidateKey.toLowerCase() === key.toLowerCase()
+        : candidateKey === key;
+    });
+    return entry?.mappedValue ?? mapping.defaultValue;
+  };
   if (Array.isArray(response)) {
-    const score = response.reduce<number>(
-      (sum, value) =>
-        sum + (values.get(mappingKey(String(value), baseType)) ?? mapping.defaultValue),
-      0,
+    const distinct = response.filter(
+      (value, index) =>
+        response.findIndex((candidate) => valuesEqual(candidate, value, false, baseType)) === index,
     );
+    const score = distinct.reduce<number>((sum, value) => sum + mappedValue(String(value)), 0);
     return clampMappedScore(score, mapping.attributes);
   }
-  const score =
-    response === null || isRecordValue(response)
-      ? 0
-      : (values.get(mappingKey(String(response), baseType)) ?? mapping.defaultValue);
+  const score = response === null || isRecordValue(response) ? 0 : mappedValue(String(response));
   return clampMappedScore(score, mapping.attributes);
 }
 

package/src/processing-state.ts

@@ -1,12 +1,13 @@
 import type {
   QtiAttemptStateV1,
+  QtiBuiltInVariables,
   QtiAttemptStatus,
   QtiDiagnostic,
   QtiPortableCustomStateValue,
   QtiValue,
 } from "./types.js";
 import { ATTEMPT_STATE_SCHEMA } from "./attempt-state-constants.js";
-import { isRecordValue } from "./processing-values.js";
+import { isRecordValue } from "./value-guards.js";
 
 export function serialize(
   itemIdentifier: string,
@@ -16,9 +17,13 @@ export function serialize(
   templateValues: Record<string, QtiValue>,
   interactionStates: Record<string, QtiPortableCustomStateValue>,
   validationMessages: QtiDiagnostic[],
+  builtInVariables?: QtiBuiltInVariables,
 ): QtiAttemptStateV1 {
   return {
     schema: ATTEMPT_STATE_SCHEMA,
+    ...(builtInVariables === undefined
+      ? {}
+      : { builtInVariables: { ...builtInVariables, context: { ...builtInVariables.context } } }),
     itemIdentifier,
     status,
     responses: cloneValueRecord(responses),

package/src/processing-values.ts

@@ -1,12 +1,7 @@
 import { parseQtiPair } from "./parser-values.js";
-import type {
-  QtiBaseType,
-  QtiRecordValue,
-  QtiResponseDeclaration,
-  QtiScalarValue,
-  QtiValue,
-} from "./types.js";
+import type { QtiBaseType, QtiResponseDeclaration, QtiScalarValue, QtiValue } from "./types.js";
 import { qtiValueToString } from "./value-format.js";
+import { isRecordValue } from "./value-guards.js";
 
 export function isNullResponse(response: QtiValue): boolean {
   return response === null || response === "" || (Array.isArray(response) && response.length === 0);
@@ -102,10 +97,6 @@ export function valueContainer(value: QtiValue): QtiScalarValue[] {
   return Array.isArray(value) ? value : [value];
 }
 
-export function isRecordValue(value: QtiValue): value is QtiRecordValue {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-
 export function containsValues(
   collection: QtiScalarValue[],
   values: QtiScalarValue[],

package/src/processing-variables.ts

@@ -7,6 +7,7 @@ import type {
   QtiTemplateDeclaration,
   QtiValue,
 } from "./types.js";
+import { builtInVariableBaseType } from "./session-builtins.js";
 import { parseBaseType } from "./parser-values.js";
 
 export function getResponseDeclaration(
@@ -37,6 +38,7 @@ export function resolveOptionalVariableValue(
   outcomes: Record<string, QtiValue>,
   templateValues: Record<string, QtiValue>,
 ): QtiValue | undefined {
+  if (identifier === "completionStatus") return outcomes.completionStatus ?? "not_attempted";
   const declaration = resolveVariableDeclaration(document, identifier);
   if (!declaration) return undefined;
   if (declaration.kind === "response") return responses[identifier] ?? null;
@@ -52,7 +54,7 @@ export function expressionIsOrdered(
   expression: QtiProcessingExpression,
   document: QtiDocument,
 ): boolean {
-  if (expression.type === "ordered") return true;
+  if (expression.type === "ordered" || expression.type === "repeat") return true;
   if (expression.type === "delete") return expressionIsOrdered(expression.collection, document);
   if (
     (expression.type === "variable" ||
@@ -77,20 +79,20 @@ export function expressionBaseType(
     expression.type === "correct" ||
     expression.type === "default"
   ) {
-    return resolveVariableDeclaration(document, expression.identifier)?.baseType;
+    return (
+      builtInVariableBaseType(expression.identifier) ??
+      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") return expressionBaseType(expression.expression, 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 commonExpressionBaseType(expression.expressions, document);
   }
   return undefined;
 }

package/src/qti-identifier.ts

@@ -0,0 +1,4 @@
+/** Whether a value is a complete QTI identifier in the supported ASCII lexical space. */
+export function isQtiIdentifier(identifier: string): boolean {
+  return /^[A-Za-z_][A-Za-z0-9_.-]*$/.test(identifier);
+}

package/src/qti-package-assets.ts

@@ -1,4 +1,5 @@
-import { pushPackageDiagnostic } from "./qti-package-paths.js";
+import { isResolvableAssetUrl } from "./asset-url.js";
+import { normalizePackagePath, pushPackageDiagnostic } from "./qti-package-paths.js";
 import { parseQtiPackageXmlTree } from "./package-xml.js";
 import type {
   QtiAssessmentTestPackageModel,
@@ -8,12 +9,7 @@ import type {
   QtiPackageContentAssetDiscovery,
   QtiPackageItem,
 } from "./qti-package-types.js";
-import {
-  isPackageRelativeHref,
-  packageDescendants,
-  resolvePackageHref,
-  type PackageXmlFile,
-} from "./qti-package-xml.js";
+import { packageDescendants, resolvePackageHref, type PackageXmlFile } from "./qti-package-xml.js";
 import type { QtiDiagnostic } from "./types.js";
 
 interface PendingAssetReference {
@@ -196,9 +192,7 @@ function collectPackageRelativeAttributeRefs(
   diagnostics: QtiDiagnostic[],
 ): void {
   for (const node of packageDescendants(xmlFile.root, localName)) {
-    const href = node.attributes[attribute];
-    if (!isPackageRelativeHref(href)) continue;
-    const resolved = resolvePackageHref(xmlFile.path, href.trim(), diagnostics);
+    const resolved = resolveContentAssetHref(xmlFile.path, node.attributes[attribute], diagnostics);
     if (resolved) refs.push(resolved);
   }
 }
@@ -210,13 +204,26 @@ function collectPackageRelativeTextRefs(
   diagnostics: QtiDiagnostic[],
 ): void {
   for (const node of packageDescendants(xmlFile.root, localName)) {
-    const href = node.text.trim();
-    if (!isPackageRelativeHref(href)) continue;
-    const resolved = resolvePackageHref(xmlFile.path, href, diagnostics);
+    const resolved = resolveContentAssetHref(xmlFile.path, node.text, diagnostics);
     if (resolved) refs.push(resolved);
   }
 }
 
+function resolveContentAssetHref(
+  sourcePath: string,
+  value: string | undefined,
+  diagnostics: QtiDiagnostic[],
+): string | undefined {
+  const href = value?.trim() ?? "";
+  // A server-root path cannot name content inside a portable QTI package.
+  // Network-path URLs are external, like URLs with an explicit scheme.
+  if (href.startsWith("/") && !href.startsWith("//")) {
+    return normalizePackagePath(href, "package asset reference", diagnostics);
+  }
+  if (!isResolvableAssetUrl(href)) return undefined;
+  return resolvePackageHref(sourcePath, href, diagnostics);
+}
+
 function materializeAssets(
   pending: readonly PendingAssetReference[],
   entriesByPath: { has(path: string): boolean },

package/src/qti-package-manifest.ts

@@ -10,6 +10,7 @@ export const QTI_PACKAGE_MANIFEST_PATH = "imsmanifest.xml";
 
 export const QTI_ITEM_RESOURCE_TYPE = "imsqti_item_xmlv3p0";
 
+/** Recognize QTI 3 item resource types, including their version suffixes. */
 export function isQtiItemResource(type: string): boolean {
   return type.toLowerCase().startsWith(QTI_ITEM_RESOURCE_TYPE);
 }

package/src/qti-package-metadata.ts

@@ -315,9 +315,20 @@ export function packageTitle(
     : undefined;
   return (
     assessmentTest?.title ??
+    manifestLomTitle(manifestRoot) ??
     manifestTitle ??
     items.find((item) => item.title !== undefined)?.title ??
     manifestRoot?.attributes.identifier ??
     ""
   );
 }
+
+function manifestLomTitle(root: QtiPackageXmlNode | undefined): string | undefined {
+  if (!root) return undefined;
+  const lomNamespace = "http://ltsc.ieee.org/xsd/LOM";
+  let nodes = childPackageElements(root, "metadata", QTI_PACKAGE_MANIFEST_NAMESPACE);
+  for (const name of ["lom", "general", "title", "string"]) {
+    nodes = nodes.flatMap((node) => childPackageElements(node, name, lomNamespace));
+  }
+  return nodes.map((node) => node.text.trim()).find((text) => text.length > 0);
+}

package/src/qti-package-paths.ts

@@ -54,3 +54,12 @@ export function normalizePackagePath(
   }
   return parts.join("/");
 }
+
+/** Whether an item href is a normalized package-local path, without URI routing or traversal. */
+export function isQtiPackageItemHref(href: string): boolean {
+  return (
+    href.length > 0 &&
+    !/^[a-z][a-z0-9+.-]*:|[\\?#\s]/i.test(href) &&
+    href.split("/").every((part) => part.length > 0 && part !== "." && part !== "..")
+  );
+}

package/src/qti-package-plan.ts

@@ -31,7 +31,7 @@ import { QTI_PACKAGE_MANIFEST_NAMESPACE } from "./qti-namespaces.js";
 import type { QtiDiagnostic } from "./types.js";
 
 /** Package metadata without extracted bodies or retained item models. */
-export type QtiPackageSummary = Omit<QtiPackageParseResult, "items" | "entries"> & {
+export type QtiPackageSummary = Omit<QtiPackageParseResult, "items" | "entries" | "xmlFiles"> & {
   readonly itemCount: number;
 };
 

package/src/qti-package-types.ts

@@ -170,11 +170,21 @@ export interface QtiPackageContentAssetDiscovery {
   readonly diagnostics: readonly QtiDiagnostic[];
 }
 
+/** Root classification and XML syntax diagnostics for one package XML file, without its tree. */
+export interface QtiPackageXmlFileSummary {
+  readonly path: string;
+  readonly rootLocalName?: string | undefined;
+  readonly rootNamespaceUri?: string | undefined;
+  readonly diagnostics: readonly QtiDiagnostic[];
+}
+
 /** Parsed QTI package manifest/resource graph and item/test projection. */
 export interface QtiPackageParseResult {
   readonly ok: boolean;
   readonly title: string;
   readonly entries: readonly QtiPackageEntry[];
+  /** All .xml entries in inventory order, including files outside the selected resource graph. */
+  readonly xmlFiles: readonly QtiPackageXmlFileSummary[];
   readonly packageShape: QtiPackageShape;
   readonly items: readonly QtiPackageItem[];
   readonly assets: readonly QtiPackageAsset[];

package/src/qti-package-xml.ts

@@ -1,3 +1,4 @@
+import { isResolvableAssetUrl } from "./asset-url.js";
 import { parseQtiPackageXmlTree, type QtiPackageXmlNode } from "./package-xml.js";
 import { normalizePackagePath, pushPackageDiagnostic } from "./qti-package-paths.js";
 import { decodeUtf8, type QtiPackageEntry } from "./qti-package-zip.js";
@@ -78,6 +79,10 @@ export function resolvePackageHref(
   diagnostics: QtiDiagnostic[],
 ): string | undefined {
   const strippedHref = stripHrefSuffix(href);
+  // Diagnose absolute package references before adding the containing directory.
+  if (!isResolvableAssetUrl(strippedHref)) {
+    return normalizePackagePath(strippedHref, "package reference", diagnostics);
+  }
   const base = from.includes("/") ? from.slice(0, from.lastIndexOf("/") + 1) : "";
   return normalizePackagePath(`${base}${strippedHref}`, "package reference", diagnostics);
 }
@@ -86,16 +91,16 @@ export function stripHrefSuffix(href: string): string {
   return href.split(/[?#]/, 1)[0] ?? "";
 }
 
-export function isPackageRelativeHref(href: string | undefined): href is string {
-  const trimmed = href?.trim() ?? "";
-  if (!trimmed || trimmed.startsWith("#") || trimmed.startsWith("//")) return false;
-  return !/^[a-z][a-z0-9+.-]*:/i.test(trimmed);
-}
-
 export function joinPackagePath(packagePath: string, localPath: string): string {
   return localPath.startsWith("/") ? `${packagePath}${localPath}` : `${packagePath}/${localPath}`;
 }
 
+/**
+ * Return a diagnostic with its local location prefixed by an item or archive path.
+ * Prefer path over source.path; update both to the same location without mutating the input.
+ * Empty locations and locations equal to packagePath resolve to packagePath itself.
+ * A leading slash in the local location is a separator, not an absolute filesystem path.
+ */
 export function scopeDiagnosticToPackagePath(
   packagePath: string,
   diagnostic: QtiDiagnostic,