@longsightgroup/qti3-core 0.9.2 → 0.9.4

package/src/qti-package-assets.ts

@@ -0,0 +1,256 @@
+import { pushPackageDiagnostic } from "./qti-package-paths.js";
+import type {
+  QtiAssessmentTestPackageModel,
+  QtiManifestResource,
+  QtiPackageAsset,
+  QtiPackageAssetSource,
+  QtiPackageItem,
+} from "./qti-package-types.js";
+import {
+  isPackageRelativeHref,
+  packageDescendants,
+  resolvePackageHref,
+  type PackageXmlFile,
+} from "./qti-package-xml.js";
+import type { QtiPackageEntry } from "./qti-package-zip.js";
+import type { QtiDiagnostic } from "./types.js";
+
+interface PendingAssetReference {
+  readonly href: string;
+  readonly source: QtiPackageAssetSource;
+  readonly referencedBy: string;
+}
+
+type PackageAssetRefSpec =
+  | { readonly kind: "attribute"; readonly localName: string; readonly attribute: string }
+  | { readonly kind: "text"; readonly localName: string };
+
+const PACKAGE_ASSET_REF_SPECS: readonly PackageAssetRefSpec[] = [
+  { kind: "attribute", localName: "qti-stylesheet", attribute: "href" },
+  { kind: "attribute", localName: "qti-assessment-stimulus-ref", attribute: "href" },
+  { kind: "attribute", localName: "img", attribute: "src" },
+  { kind: "attribute", localName: "object", attribute: "data" },
+  { kind: "attribute", localName: "audio", attribute: "src" },
+  { kind: "attribute", localName: "video", attribute: "src" },
+  { kind: "attribute", localName: "source", attribute: "src" },
+  { kind: "attribute", localName: "track", attribute: "src" },
+  { kind: "text", localName: "qti-file-href" },
+  { kind: "text", localName: "qti-resource-icon" },
+];
+
+export function discoverContentAssetHrefs(
+  xmlFile: PackageXmlFile,
+  diagnostics: QtiDiagnostic[],
+): string[] {
+  if (!xmlFile.root) return [];
+
+  const refs: string[] = [];
+  for (const spec of PACKAGE_ASSET_REF_SPECS) {
+    if (spec.kind === "attribute") {
+      collectPackageRelativeAttributeRefs(
+        refs,
+        xmlFile,
+        spec.localName,
+        spec.attribute,
+        diagnostics,
+      );
+    } else {
+      collectPackageRelativeTextRefs(refs, xmlFile, spec.localName, diagnostics);
+    }
+  }
+  return [...new Set(refs)];
+}
+
+export function collectPackageAssets(
+  resourcesByIdentifier: ReadonlyMap<string, QtiManifestResource>,
+  assessmentTest: QtiAssessmentTestPackageModel | undefined,
+  items: readonly QtiPackageItem[],
+  entriesByPath: ReadonlyMap<string, QtiPackageEntry>,
+  diagnostics: QtiDiagnostic[],
+): QtiPackageAsset[] {
+  const pending: PendingAssetReference[] = [];
+  const selectedResourceIds = new Set<string>();
+  if (assessmentTest?.manifestResourceIdentifier !== undefined) {
+    selectedResourceIds.add(assessmentTest.manifestResourceIdentifier);
+  }
+  for (const item of items) {
+    if (item.manifestResourceIdentifier !== undefined) {
+      selectedResourceIds.add(item.manifestResourceIdentifier);
+    }
+  }
+
+  for (const resourceId of selectedResourceIds) {
+    for (const resource of resourceClosure(resourceId, resourcesByIdentifier)) {
+      for (const file of resource.files) {
+        if (isPrimaryPackageXml(file.href, assessmentTest, items)) continue;
+        pending.push({
+          href: file.href,
+          source: "manifest-resource",
+          referencedBy: resource.identifier,
+        });
+      }
+    }
+  }
+
+  if (assessmentTest) {
+    for (const itemRef of assessmentTest.itemRefs) {
+      if (!entriesByPath.has(itemRef.href)) {
+        pushPackageDiagnostic(
+          diagnostics,
+          "package.reference.missing",
+          "error",
+          `Assessment test item reference ${itemRef.href} was not found in the package.`,
+          itemRef.href,
+        );
+      }
+    }
+    for (const href of assessmentTest.assetHrefs) {
+      pending.push({ href, source: "assessment-test-content", referencedBy: assessmentTest.href });
+      if (!entriesByPath.has(href)) {
+        pushPackageDiagnostic(
+          diagnostics,
+          "package.asset.missing",
+          "error",
+          `Package asset ${href} referenced from ${assessmentTest.href} was not found.`,
+          href,
+        );
+      }
+    }
+  }
+
+  for (const item of items) {
+    for (const href of item.assetHrefs) {
+      pending.push({ href, source: "item-content", referencedBy: item.href });
+      if (!entriesByPath.has(href)) {
+        pushPackageDiagnostic(
+          diagnostics,
+          "package.asset.missing",
+          "error",
+          `Package asset ${href} referenced from ${item.href} was not found.`,
+          href,
+        );
+      }
+    }
+  }
+
+  return materializeAssets(pending, entriesByPath);
+}
+
+function resourceClosure(
+  rootIdentifier: string,
+  resourcesByIdentifier: ReadonlyMap<string, QtiManifestResource>,
+): QtiManifestResource[] {
+  const closed: QtiManifestResource[] = [];
+  const visited = new Set<string>();
+  const pending = [rootIdentifier];
+
+  for (let index = 0; index < pending.length; index += 1) {
+    const identifier = pending[index];
+    if (!identifier || visited.has(identifier)) continue;
+    visited.add(identifier);
+    const resource = resourcesByIdentifier.get(identifier);
+    if (!resource) continue;
+    closed.push(resource);
+    pending.push(...resource.dependencies);
+  }
+
+  return closed;
+}
+
+function isPrimaryPackageXml(
+  href: string,
+  assessmentTest: QtiAssessmentTestPackageModel | undefined,
+  items: readonly { readonly href: string }[],
+): boolean {
+  if (assessmentTest?.href === href) return true;
+  return items.some((item) => item.href === href);
+}
+
+function collectPackageRelativeAttributeRefs(
+  refs: string[],
+  xmlFile: PackageXmlFile,
+  localName: string,
+  attribute: string,
+  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);
+    if (resolved) refs.push(resolved);
+  }
+}
+
+function collectPackageRelativeTextRefs(
+  refs: string[],
+  xmlFile: PackageXmlFile,
+  localName: string,
+  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);
+    if (resolved) refs.push(resolved);
+  }
+}
+
+function materializeAssets(
+  pending: readonly PendingAssetReference[],
+  entriesByPath: ReadonlyMap<string, QtiPackageEntry>,
+): QtiPackageAsset[] {
+  const assetsByHref = new Map<string, PendingAssetReference[]>();
+  for (const reference of pending) {
+    if (!entriesByPath.has(reference.href)) continue;
+    const references = assetsByHref.get(reference.href) ?? [];
+    references.push(reference);
+    assetsByHref.set(reference.href, references);
+  }
+
+  return [...assetsByHref.entries()]
+    .map(([href, references]): QtiPackageAsset => {
+      const firstReference = references[0];
+      return {
+        href,
+        mediaType: detectPackageMediaType(href),
+        source: firstReference?.source ?? "item-content",
+        referencedBy: [...new Set(references.map((reference) => reference.referencedBy))],
+      };
+    })
+    .toSorted((left, right) => left.href.localeCompare(right.href));
+}
+
+export function detectPackageMediaType(href: string): string | undefined {
+  const extension = href.slice(href.lastIndexOf(".") + 1).toLowerCase();
+  switch (extension) {
+    case "css":
+      return "text/css";
+    case "gif":
+      return "image/gif";
+    case "jpg":
+    case "jpeg":
+      return "image/jpeg";
+    case "mp3":
+      return "audio/mpeg";
+    case "mp4":
+      return "video/mp4";
+    case "ogg":
+      return "audio/ogg";
+    case "png":
+      return "image/png";
+    case "svg":
+      return "image/svg+xml";
+    case "vtt":
+      return "text/vtt";
+    case "wav":
+      return "audio/wav";
+    case "webm":
+      return "video/webm";
+    case "webp":
+      return "image/webp";
+    case "xml":
+      return "application/xml";
+    default:
+      return undefined;
+  }
+}

package/src/qti-package-items.ts

@@ -0,0 +1,240 @@
+import type { QtiPackageXmlNode } from "./package-xml.js";
+import { parseQtiXml } from "./parser.js";
+import { pushPackageDiagnostic } from "./qti-package-paths.js";
+import { discoverContentAssetHrefs } from "./qti-package-assets.js";
+import { QTI_PACKAGE_MANIFEST_PATH } from "./qti-package-manifest.js";
+import { parseStandardAlignments, parseTimingMetadata } from "./qti-package-metadata.js";
+import type {
+  QtiAssessmentTestItemRef,
+  QtiAssessmentTestPackageModel,
+  QtiManifestResource,
+  QtiPackageItem,
+  QtiPackageItemSource,
+  QtiPackageShape,
+} from "./qti-package-types.js";
+import {
+  packageDescendants,
+  parsePackageXml,
+  pushXmlDiagnostics,
+  resolvePackageHref,
+  scopeDiagnosticToPackagePath,
+  type PackageXmlFile,
+} from "./qti-package-xml.js";
+import type { QtiPackageEntry } from "./qti-package-zip.js";
+import type { QtiDiagnostic } from "./types.js";
+
+export interface PackageItemReference {
+  readonly href: string;
+  readonly source: QtiPackageItemSource;
+  readonly manifestResourceIdentifier?: string | undefined;
+  readonly assessmentItemRefIdentifier?: string | undefined;
+}
+
+export function parseAssessmentTestPackageModel(
+  packageShape: QtiPackageShape,
+  assessmentTestResources: readonly QtiManifestResource[],
+  entriesByPath: ReadonlyMap<string, QtiPackageEntry>,
+  xmlFilesByPath: ReadonlyMap<string, PackageXmlFile>,
+  diagnostics: QtiDiagnostic[],
+): QtiAssessmentTestPackageModel | undefined {
+  if (packageShape !== "assessment-test-resource") return undefined;
+
+  const firstResource = assessmentTestResources[0];
+  if (!firstResource) return undefined;
+
+  if (assessmentTestResources.length > 1) {
+    pushPackageDiagnostic(
+      diagnostics,
+      "package.assessmentTest.resource.ambiguous",
+      "error",
+      "Manifest contains multiple QTI assessment-test resources.",
+      QTI_PACKAGE_MANIFEST_PATH,
+    );
+  }
+
+  const href = firstResource.href;
+  if (!href) return undefined;
+  if (!entriesByPath.has(href)) {
+    pushPackageDiagnostic(
+      diagnostics,
+      "package.assessmentTest.missing",
+      "error",
+      `Assessment test resource ${href} was not found in the package.`,
+      href,
+    );
+    return undefined;
+  }
+
+  const entry = entriesByPath.get(href);
+  if (!entry) return undefined;
+  const xmlFile = xmlFilesByPath.get(href) ?? parsePackageXml(entry);
+  const testDiagnostics: QtiDiagnostic[] = [];
+  pushXmlDiagnostics(xmlFile, testDiagnostics);
+  const root = xmlFile.root?.localName === "qti-assessment-test" ? xmlFile.root : undefined;
+  if (xmlFile.root && !root) {
+    pushPackageDiagnostic(
+      testDiagnostics,
+      "package.assessmentTest.root",
+      "error",
+      `Expected qti-assessment-test root, found ${xmlFile.root.localName}.`,
+      href,
+    );
+  }
+
+  const itemRefs = root ? parseAssessmentTestItemRefs(root, href, testDiagnostics) : [];
+  const assetHrefs = root ? discoverContentAssetHrefs(xmlFile, testDiagnostics) : [];
+  const scopedDiagnostics = testDiagnostics.map((diagnostic) =>
+    scopeDiagnosticToPackagePath(href, diagnostic),
+  );
+  diagnostics.push(...scopedDiagnostics);
+
+  return {
+    href,
+    identifier: root?.attributes.identifier ?? "",
+    title: root?.attributes.title,
+    manifestResourceIdentifier: firstResource.identifier,
+    itemRefs,
+    timing: root ? parseTimingMetadata(root, href) : undefined,
+    standards: root ? parseStandardAlignments(root, href) : [],
+    assetHrefs,
+    diagnostics: scopedDiagnostics,
+    attributes: root ? { ...root.attributes } : {},
+    xml: xmlFile.xml,
+  };
+}
+
+function parseAssessmentTestItemRefs(
+  root: QtiPackageXmlNode,
+  sourcePath: string,
+  diagnostics: QtiDiagnostic[],
+): QtiAssessmentTestItemRef[] {
+  const itemRefs: QtiAssessmentTestItemRef[] = [];
+  for (const refNode of packageDescendants(root, "qti-assessment-item-ref")) {
+    const rawHref = refNode.attributes.href;
+    if (!rawHref) {
+      pushPackageDiagnostic(
+        diagnostics,
+        "package.assessmentTest.itemRef.href.missing",
+        "error",
+        "qti-assessment-item-ref is missing href.",
+        sourcePath,
+      );
+      continue;
+    }
+
+    const href = resolvePackageHref(sourcePath, rawHref, diagnostics);
+    if (!href) continue;
+    itemRefs.push({
+      identifier: refNode.attributes.identifier,
+      href,
+      attributes: { ...refNode.attributes },
+    });
+  }
+  return itemRefs;
+}
+
+export function itemReferencesForPackageShape(
+  packageShape: QtiPackageShape,
+  itemResources: readonly QtiManifestResource[],
+  assessmentTest: QtiAssessmentTestPackageModel | undefined,
+  diagnostics: QtiDiagnostic[],
+): PackageItemReference[] {
+  if (packageShape === "assessment-test-resource") {
+    return (assessmentTest?.itemRefs ?? []).map((itemRef) => ({
+      href: itemRef.href,
+      source: "assessment-test",
+      assessmentItemRefIdentifier: itemRef.identifier,
+    }));
+  }
+
+  if (packageShape !== "manifest-item-resources") return [];
+
+  const references: PackageItemReference[] = [];
+  const seen = new Set<string>();
+  for (const resource of itemResources) {
+    const href = resource.href;
+    if (!href) continue;
+    if (seen.has(href)) {
+      pushPackageDiagnostic(
+        diagnostics,
+        "package.manifest.itemResource.href.duplicate",
+        "error",
+        `Multiple manifest item resources point to ${href}.`,
+        href,
+      );
+      continue;
+    }
+    seen.add(href);
+    references.push({
+      href,
+      source: "manifest",
+      manifestResourceIdentifier: resource.identifier,
+    });
+  }
+  return references;
+}
+
+export function parsePackageItems(
+  references: readonly PackageItemReference[],
+  entriesByPath: ReadonlyMap<string, QtiPackageEntry>,
+  xmlFilesByPath: ReadonlyMap<string, PackageXmlFile>,
+  diagnostics: QtiDiagnostic[],
+): QtiPackageItem[] {
+  const items: QtiPackageItem[] = [];
+  const seen = new Set<string>();
+
+  for (const reference of references) {
+    if (seen.has(reference.href)) {
+      pushPackageDiagnostic(
+        diagnostics,
+        "package.item.reference.duplicate",
+        "warning",
+        `Package item ${reference.href} is referenced more than once.`,
+        reference.href,
+      );
+      continue;
+    }
+    seen.add(reference.href);
+
+    const entry = entriesByPath.get(reference.href);
+    if (!entry) {
+      pushPackageDiagnostic(
+        diagnostics,
+        "package.item.missing",
+        "error",
+        `Package item reference ${reference.href} was not found.`,
+        reference.href,
+      );
+      continue;
+    }
+
+    const xmlFile = xmlFilesByPath.get(reference.href) ?? parsePackageXml(entry);
+    // Full QTI parse for document model; lightweight tree above supplies metadata and asset refs.
+    const parsed = parseQtiXml(xmlFile.xml);
+    const itemDiagnostics = parsed.diagnostics.map((diagnostic) =>
+      scopeDiagnosticToPackagePath(reference.href, diagnostic),
+    );
+    diagnostics.push(...itemDiagnostics);
+
+    const assetHrefs = xmlFile.root ? discoverContentAssetHrefs(xmlFile, diagnostics) : [];
+    const root = xmlFile.root?.localName === "qti-assessment-item" ? xmlFile.root : undefined;
+    const item = parsed.document?.item;
+
+    items.push({
+      href: reference.href,
+      source: reference.source,
+      manifestResourceIdentifier: reference.manifestResourceIdentifier,
+      assessmentItemRefIdentifier: reference.assessmentItemRefIdentifier,
+      identifier: item?.identifier,
+      title: item?.title,
+      document: parsed.document,
+      timing: root ? parseTimingMetadata(root, reference.href) : undefined,
+      standards: root ? parseStandardAlignments(root, reference.href) : [],
+      assetHrefs,
+      diagnostics: itemDiagnostics,
+      xml: xmlFile.xml,
+    });
+  }
+
+  return items;
+}

package/src/qti-package-manifest.ts

@@ -0,0 +1,210 @@
+import type { QtiPackageXmlNode } from "./package-xml.js";
+import { normalizePackagePath, pushPackageDiagnostic } from "./qti-package-paths.js";
+import type { QtiManifestFile, QtiManifestResource, QtiPackageShape } from "./qti-package-types.js";
+import { childPackageElements, packageDescendants, stripHrefSuffix } from "./qti-package-xml.js";
+import type { QtiPackageEntry } from "./qti-package-zip.js";
+import type { QtiDiagnostic } from "./types.js";
+
+export const QTI_PACKAGE_MANIFEST_PATH = "imsmanifest.xml";
+
+export function isQtiItemResource(type: string): boolean {
+  return type.toLowerCase().startsWith("imsqti_item_xmlv3p0");
+}
+
+export function isQtiAssessmentTestResource(type: string): boolean {
+  return type.toLowerCase().startsWith("imsqti_test_xmlv3p0");
+}
+
+export function parseManifestResources(
+  manifestRoot: QtiPackageXmlNode,
+  entriesByPath: ReadonlyMap<string, QtiPackageEntry>,
+  diagnostics: QtiDiagnostic[],
+): QtiManifestResource[] {
+  const resourceNodes = packageDescendants(manifestRoot, "resources").flatMap((resources) =>
+    childPackageElements(resources, "resource"),
+  );
+  const resources: QtiManifestResource[] = [];
+
+  for (const node of resourceNodes) {
+    const identifier = node.attributes.identifier ?? "";
+    if (identifier.length === 0) {
+      pushPackageDiagnostic(
+        diagnostics,
+        "package.manifest.resource.identifier.missing",
+        "error",
+        "Manifest resource is missing an identifier.",
+        QTI_PACKAGE_MANIFEST_PATH,
+      );
+    }
+
+    const files = parseManifestFiles(node, entriesByPath, diagnostics);
+    const href =
+      node.attributes.href === undefined
+        ? firstXmlManifestFileHref(files)
+        : normalizePackagePath(
+            stripHrefSuffix(node.attributes.href),
+            `manifest resource ${identifier || "(missing identifier)"} href`,
+            diagnostics,
+          );
+    const dependencies = parseManifestDependencies(node, diagnostics);
+
+    resources.push({
+      identifier,
+      type: node.attributes.type ?? "",
+      href,
+      files,
+      dependencies,
+      attributes: { ...node.attributes },
+    });
+  }
+
+  return resources;
+}
+
+function parseManifestFiles(
+  resourceNode: QtiPackageXmlNode,
+  entriesByPath: ReadonlyMap<string, QtiPackageEntry>,
+  diagnostics: QtiDiagnostic[],
+): QtiManifestFile[] {
+  const files: QtiManifestFile[] = [];
+  for (const fileNode of packageDescendants(resourceNode, "file")) {
+    const rawHref = fileNode.attributes.href;
+    if (!rawHref) {
+      pushPackageDiagnostic(
+        diagnostics,
+        "package.manifest.file.href.missing",
+        "error",
+        "Manifest file entry is missing href.",
+        QTI_PACKAGE_MANIFEST_PATH,
+      );
+      continue;
+    }
+
+    const href = normalizePackagePath(stripHrefSuffix(rawHref), "manifest file href", diagnostics);
+    if (!href) continue;
+    files.push({ href, attributes: { ...fileNode.attributes } });
+    if (!entriesByPath.has(href)) {
+      pushPackageDiagnostic(
+        diagnostics,
+        "package.manifest.file.missing",
+        "error",
+        `Manifest file reference ${href} was not found in the package.`,
+        href,
+      );
+    }
+  }
+  return files;
+}
+
+function parseManifestDependencies(
+  resourceNode: QtiPackageXmlNode,
+  diagnostics: QtiDiagnostic[],
+): string[] {
+  const dependencies: string[] = [];
+  for (const dependencyNode of packageDescendants(resourceNode, "dependency")) {
+    const identifierref = dependencyNode.attributes.identifierref;
+    if (!identifierref) {
+      pushPackageDiagnostic(
+        diagnostics,
+        "package.manifest.dependency.identifierref.missing",
+        "error",
+        "Manifest dependency is missing identifierref.",
+        QTI_PACKAGE_MANIFEST_PATH,
+      );
+      continue;
+    }
+    dependencies.push(identifierref);
+  }
+  return [...new Set(dependencies)];
+}
+
+function firstXmlManifestFileHref(files: readonly QtiManifestFile[]): string | undefined {
+  return files.find((file) => file.href.toLowerCase().endsWith(".xml"))?.href;
+}
+
+export function indexManifestResources(
+  resources: readonly QtiManifestResource[],
+  diagnostics: QtiDiagnostic[],
+): Map<string, QtiManifestResource> {
+  const byIdentifier = new Map<string, QtiManifestResource>();
+  for (const resource of resources) {
+    const identifier = resource.identifier;
+    if (identifier.length === 0) continue;
+    if (byIdentifier.has(identifier)) {
+      pushPackageDiagnostic(
+        diagnostics,
+        "package.manifest.resource.identifier.duplicate",
+        "error",
+        `Manifest contains duplicate resource identifier ${identifier}.`,
+        QTI_PACKAGE_MANIFEST_PATH,
+      );
+      continue;
+    }
+    byIdentifier.set(identifier, resource);
+  }
+  return byIdentifier;
+}
+
+export function diagnoseManifestDependencyReferences(
+  resources: readonly QtiManifestResource[],
+  resourcesByIdentifier: ReadonlyMap<string, QtiManifestResource>,
+  diagnostics: QtiDiagnostic[],
+): void {
+  for (const resource of resources) {
+    for (const dependency of resource.dependencies) {
+      if (resourcesByIdentifier.has(dependency)) continue;
+      pushPackageDiagnostic(
+        diagnostics,
+        "package.manifest.dependency.missing",
+        "error",
+        `Manifest resource ${resource.identifier} depends on missing resource ${dependency}.`,
+        QTI_PACKAGE_MANIFEST_PATH,
+      );
+    }
+  }
+}
+
+export function diagnosePrimaryResourceHrefs(
+  resources: readonly QtiManifestResource[],
+  diagnostics: QtiDiagnostic[],
+): void {
+  for (const resource of resources) {
+    if (resource.href) continue;
+    pushPackageDiagnostic(
+      diagnostics,
+      "package.manifest.resource.href.missing",
+      "error",
+      `Manifest resource ${resource.identifier || "(missing identifier)"} is missing a primary XML href.`,
+      QTI_PACKAGE_MANIFEST_PATH,
+    );
+  }
+}
+
+export function detectPackageShape(
+  itemResources: readonly QtiManifestResource[],
+  assessmentTestResources: readonly QtiManifestResource[],
+  diagnostics: QtiDiagnostic[],
+): QtiPackageShape {
+  if (assessmentTestResources.length > 0 && itemResources.length > 0) {
+    pushPackageDiagnostic(
+      diagnostics,
+      "package.shape.ambiguous",
+      "error",
+      "Manifest contains both QTI item resources and QTI assessment-test resources.",
+      QTI_PACKAGE_MANIFEST_PATH,
+    );
+    return "unknown";
+  }
+
+  if (assessmentTestResources.length > 0) return "assessment-test-resource";
+  if (itemResources.length > 0) return "manifest-item-resources";
+
+  pushPackageDiagnostic(
+    diagnostics,
+    "package.shape.unsupported",
+    "error",
+    "Manifest does not contain QTI item or assessment-test resources.",
+    QTI_PACKAGE_MANIFEST_PATH,
+  );
+  return "unknown";
+}