@longsightgroup/qti3-core 0.10.4 → 0.10.6

package/src/qti-package-stream.ts

@@ -0,0 +1,254 @@
+import {
+  itemReferencesForPackageShape,
+  parseAssessmentTestPackageModel,
+  parsePackageItem,
+} from "./qti-package-items.js";
+import { QTI_PACKAGE_MANIFEST_PATH } from "./qti-package-manifest.js";
+import {
+  buildPackageSummary,
+  enforceDiagnosticLimit,
+  failedPackageSummary,
+  inspectPackageManifest,
+  type QtiPackageSummary,
+} from "./qti-package-plan.js";
+import { normalizePackagePath, pushPackageDiagnostic } from "./qti-package-paths.js";
+import type { QtiPackageItem } from "./qti-package-types.js";
+import { parsePackageXml } from "./qti-package-xml.js";
+import type { QtiPackageEntry } from "./qti-package-zip.js";
+import type { QtiDiagnostic } from "./types.js";
+
+/** An immutable entry inventory and host-owned, bounded reads of decoded entry bytes. */
+export interface QtiPackageSource {
+  readonly entries: readonly { readonly path: string; readonly size: number }[];
+  /** Enforce maxBytes during extraction, before allocating an oversized body. */
+  readonly readEntry: (path: string, maxBytes: number) => Promise<Uint8Array>;
+}
+
+/** Explicit resource budgets for an incremental package read. */
+export interface QtiPackageStreamLimits {
+  readonly maxEntries: number;
+  readonly maxEntryBytes: number;
+  readonly maxTotalBytes: number;
+  readonly maxDiagnostics: number;
+}
+
+/** Package metadata without extracted bodies or retained item models. */
+export type QtiPackageStreamSummary = QtiPackageSummary;
+
+/** Items are provisional until the terminal summary reports ok; hosts must stage them. */
+export type QtiPackageStreamEvent =
+  | { readonly kind: "item"; readonly index: number; readonly item: QtiPackageItem }
+  | { readonly kind: "summary"; readonly summary: QtiPackageStreamSummary };
+
+/**
+ * Parse immutable package entries sequentially with canonical package semantics.
+ *
+ * The caller owns ZIP/object storage and must not collect item events when bounded
+ * memory is required. Assets are described in the terminal summary, never loaded.
+ * Breaking iteration stops subsequent reads. Read failures become safe diagnostics.
+ */
+export async function* parseQtiPackageStream(
+  source: QtiPackageSource,
+  limits: QtiPackageStreamLimits,
+): AsyncGenerator<QtiPackageStreamEvent> {
+  const diagnostics: QtiDiagnostic[] = [];
+  const inventory = inspectInventory(source, limits, diagnostics);
+  if (!inventory) {
+    yield { kind: "summary", summary: failedPackageSummary(diagnostics) };
+    return;
+  }
+  const read = createEntryReader(source, inventory, limits, diagnostics);
+  const manifestEntry = await read(QTI_PACKAGE_MANIFEST_PATH);
+  const manifest = inspectPackageManifest(
+    inventory,
+    manifestEntry ? parsePackageXml(manifestEntry) : undefined,
+    diagnostics,
+  );
+  // Only the primary assessment test supplies the package structure. The shared
+  // parser diagnoses additional test resources without loading their bodies.
+  const testEntries = new Map<string, QtiPackageEntry>();
+  const testHref = manifest.assessmentTestResources[0]?.href;
+  if (testHref !== undefined) {
+    const entry = await read(testHref);
+    if (entry) testEntries.set(testHref, entry);
+  }
+  const assessmentTest = parseAssessmentTestPackageModel(
+    manifest.packageShape,
+    manifest.assessmentTestResources,
+    testEntries,
+    new Map(),
+    diagnostics,
+  );
+  const references = itemReferencesForPackageShape(
+    manifest.packageShape,
+    manifest.itemResources,
+    assessmentTest,
+    diagnostics,
+  );
+  const assetItems: Pick<QtiPackageItem, "href" | "manifestResourceIdentifier" | "assetHrefs">[] =
+    [];
+  const itemStandards: QtiPackageItem["standards"][number][] = [];
+  const titleItems: Pick<QtiPackageItem, "title">[] = [];
+  const seen = new Set<string>();
+  let itemCount = 0;
+  let timedItemCount = 0;
+  let soleItemTiming: QtiPackageItem["timing"] | undefined;
+  for (const reference of references) {
+    if (diagnostics.length >= limits.maxDiagnostics) break;
+    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 = await read(reference.href);
+    if (!entry) continue;
+    const item = parsePackageItem(reference, entry, undefined, diagnostics);
+    if (item.title !== undefined && titleItems.length === 0) {
+      titleItems.push({ title: item.title });
+    }
+    if (item.timing !== undefined) {
+      timedItemCount += 1;
+      soleItemTiming = item.timing;
+    }
+    itemStandards.push(...item.standards);
+    assetItems.push({
+      href: item.href,
+      manifestResourceIdentifier: item.manifestResourceIdentifier,
+      assetHrefs: item.assetHrefs,
+    });
+    yield { kind: "item", index: itemCount++, item };
+  }
+  enforceDiagnosticLimit(diagnostics, limits.maxDiagnostics);
+  yield {
+    kind: "summary",
+    summary: buildPackageSummary({
+      manifestRoot: manifest.manifestRoot,
+      manifestResources: manifest.manifestResources,
+      resourcesByIdentifier: manifest.resourcesByIdentifier,
+      packageShape: manifest.packageShape,
+      assessmentTest,
+      assetItems,
+      titleItems,
+      timedItemCount,
+      soleItemTiming,
+      itemStandards,
+      entriesByPath: inventory,
+      diagnostics,
+      itemCount,
+    }),
+  };
+}
+
+function createEntryReader(
+  source: QtiPackageSource,
+  inventory: ReadonlyMap<string, number>,
+  limits: QtiPackageStreamLimits,
+  diagnostics: QtiDiagnostic[],
+): (path: string) => Promise<QtiPackageEntry | undefined> {
+  return async (path) => {
+    const size = inventory.get(path);
+    if (size === undefined) return undefined;
+    try {
+      const bytes = await source.readEntry(path, limits.maxEntryBytes);
+      if (!(bytes instanceof Uint8Array) || bytes.byteLength !== size) {
+        pushPackageDiagnostic(
+          diagnostics,
+          "package.entry.size",
+          "error",
+          "Package entry size does not match its immutable inventory.",
+          path,
+        );
+        return undefined;
+      }
+      return { path, bytes };
+    } catch {
+      pushPackageDiagnostic(
+        diagnostics,
+        "package.entry.read",
+        "error",
+        "Package entry could not be read.",
+        path,
+      );
+      return undefined;
+    }
+  };
+}
+
+function inspectInventory(
+  source: QtiPackageSource,
+  limits: QtiPackageStreamLimits,
+  diagnostics: QtiDiagnostic[],
+): Map<string, number> | undefined {
+  if (!validStreamLimits(limits)) {
+    pushPackageDiagnostic(
+      diagnostics,
+      "package.limits.invalid",
+      "error",
+      "Package limits must be positive safe integers.",
+    );
+    return undefined;
+  }
+  if (source.entries.length > limits.maxEntries) {
+    pushPackageDiagnostic(
+      diagnostics,
+      "package.entries.limit",
+      "error",
+      "Package contains more entries than allowed.",
+    );
+    return undefined;
+  }
+  const inventory = new Map<string, number>();
+  let total = 0;
+  for (const entry of source.entries) {
+    const path = normalizePackagePath(entry.path, "entry", diagnostics);
+    if (!path) return undefined;
+    if (path !== entry.path || inventory.has(path)) {
+      pushPackageDiagnostic(
+        diagnostics,
+        "package.entry.duplicate",
+        "error",
+        "Package inventory paths must be unique and canonical.",
+        entry.path,
+      );
+      return undefined;
+    }
+    total += entry.size;
+    if (
+      !Number.isSafeInteger(entry.size) ||
+      entry.size < 0 ||
+      entry.size > limits.maxEntryBytes ||
+      !Number.isSafeInteger(total) ||
+      total > limits.maxTotalBytes
+    ) {
+      pushPackageDiagnostic(
+        diagnostics,
+        "package.bytes.limit",
+        "error",
+        "Package entry or total size exceeds its configured budget.",
+        path,
+      );
+      return undefined;
+    }
+    inventory.set(path, entry.size);
+  }
+  return inventory;
+}
+
+function validStreamLimits(limits: QtiPackageStreamLimits): boolean {
+  return (
+    Number.isSafeInteger(limits.maxEntries) &&
+    limits.maxEntries > 0 &&
+    Number.isSafeInteger(limits.maxEntryBytes) &&
+    limits.maxEntryBytes > 0 &&
+    Number.isSafeInteger(limits.maxTotalBytes) &&
+    limits.maxTotalBytes > 0 &&
+    Number.isSafeInteger(limits.maxDiagnostics) &&
+    limits.maxDiagnostics > 0
+  );
+}

package/src/qti-package.ts

@@ -1,29 +1,13 @@
 import { pushPackageDiagnostic } from "./qti-package-paths.js";
-import { collectPackageAssets } from "./qti-package-assets.js";
-import {
-  detectPackageShape,
-  diagnoseManifestDependencyReferences,
-  diagnosePrimaryResourceHrefs,
-  indexManifestResources,
-  isQtiAssessmentTestResource,
-  isQtiItemResource,
-  parseManifestResources,
-  QTI_PACKAGE_MANIFEST_PATH,
-} from "./qti-package-manifest.js";
+import { QTI_PACKAGE_MANIFEST_PATH } from "./qti-package-manifest.js";
+import { buildPackageSummary, inspectPackageManifest } from "./qti-package-plan.js";
 import {
   itemReferencesForPackageShape,
   parseAssessmentTestPackageModel,
   parsePackageItems,
 } from "./qti-package-items.js";
-import {
-  packageTitle,
-  parseStandardAlignments,
-  primaryTiming,
-  uniqueStandards,
-} from "./qti-package-metadata.js";
 import type { QtiPackageParseResult } from "./qti-package-types.js";
-import { QTI_PACKAGE_MANIFEST_NAMESPACE } from "./qti-namespaces.js";
-import { parseXmlFiles, pushXmlDiagnostics } from "./qti-package-xml.js";
+import { parseXmlFiles } from "./qti-package-xml.js";
 import {
   DEFAULT_QTI_PACKAGE_RESOURCE_LIMITS,
   decodeUtf8,
@@ -85,53 +69,18 @@ function parseQtiPackageEntries(
 ): QtiPackageParseResult {
   const entriesByPath = indexEntries(entries, diagnostics);
   const xmlFilesByPath = parseXmlFiles(entriesByPath);
-  const manifestXml = xmlFilesByPath.get(QTI_PACKAGE_MANIFEST_PATH);
-
-  if (!manifestXml) {
-    pushPackageDiagnostic(
-      diagnostics,
-      "package.manifest.missing",
-      "error",
-      "QTI package does not contain imsmanifest.xml.",
-      QTI_PACKAGE_MANIFEST_PATH,
-    );
-  } else {
-    pushXmlDiagnostics(manifestXml, diagnostics);
-  }
-
-  const manifestRoot =
-    manifestXml?.root?.localName === "manifest" &&
-    manifestXml.root.uri === QTI_PACKAGE_MANIFEST_NAMESPACE
-      ? manifestXml.root
-      : undefined;
-  if (manifestXml?.root && !manifestRoot) {
-    pushPackageDiagnostic(
-      diagnostics,
-      "package.manifest.root",
-      "error",
-      manifestXml.root.localName === "manifest"
-        ? `Expected imsmanifest.xml manifest in namespace ${QTI_PACKAGE_MANIFEST_NAMESPACE}, found ${manifestXml.root.uri ?? "(none)"}.`
-        : `Expected imsmanifest.xml root manifest, found ${manifestXml.root.localName}.`,
-      QTI_PACKAGE_MANIFEST_PATH,
-    );
-  }
-
-  const manifestResourceRecords = manifestRoot
-    ? parseManifestResources(manifestRoot, entriesByPath, diagnostics)
-    : [];
-  const manifestResources = manifestResourceRecords;
-  const resourcesByIdentifier = indexManifestResources(manifestResourceRecords, diagnostics);
-  diagnoseManifestDependencyReferences(manifestResourceRecords, resourcesByIdentifier, diagnostics);
-
-  const itemResources = manifestResourceRecords.filter((resource) =>
-    isQtiItemResource(resource.type),
-  );
-  const assessmentTestResources = manifestResourceRecords.filter((resource) =>
-    isQtiAssessmentTestResource(resource.type),
+  const {
+    manifestRoot,
+    manifestResources,
+    resourcesByIdentifier,
+    itemResources,
+    assessmentTestResources,
+    packageShape,
+  } = inspectPackageManifest(
+    entriesByPath,
+    xmlFilesByPath.get(QTI_PACKAGE_MANIFEST_PATH),
+    diagnostics,
   );
-  diagnosePrimaryResourceHrefs([...itemResources, ...assessmentTestResources], diagnostics);
-
-  const packageShape = detectPackageShape(itemResources, assessmentTestResources, diagnostics);
   const assessmentTest = parseAssessmentTestPackageModel(
     packageShape,
     assessmentTestResources,
@@ -146,36 +95,27 @@ function parseQtiPackageEntries(
     diagnostics,
   );
   const items = parsePackageItems(itemReferences, entriesByPath, xmlFilesByPath, diagnostics);
-  const assets = collectPackageAssets(
+  const timedItems = items.filter((item) => item.timing !== undefined);
+  const { itemCount: _itemCount, ...summary } = buildPackageSummary({
+    manifestRoot,
+    manifestResources,
     resourcesByIdentifier,
+    packageShape,
     assessmentTest,
-    items,
+    assetItems: items,
+    titleItems: items,
+    timedItemCount: timedItems.length,
+    soleItemTiming: timedItems.length === 1 ? timedItems[0]?.timing : undefined,
+    itemStandards: items.flatMap((item) => item.standards),
     entriesByPath,
     diagnostics,
-  );
-  const manifestStandards = manifestRoot
-    ? parseStandardAlignments(manifestRoot, QTI_PACKAGE_MANIFEST_PATH)
-    : [];
-  const standards = uniqueStandards([
-    ...manifestStandards,
-    ...(assessmentTest?.standards ?? []),
-    ...items.flatMap((item) => item.standards),
-  ]);
-  const timing = primaryTiming(assessmentTest, items);
-  const title = packageTitle(manifestRoot, assessmentTest, items);
+    itemCount: items.length,
+  });
 
   return {
-    ok: diagnostics.every((diagnostic) => diagnostic.severity !== "error"),
-    title,
+    ...summary,
     entries,
-    packageShape,
     items,
-    assets,
-    manifestResources,
-    assessmentTest,
-    timing,
-    standards,
-    diagnostics,
   };
 }
 

package/src/response-validation-policy.ts

@@ -31,6 +31,8 @@ export function responseLimitAttribute(
   choiceKey: "min-choices" | "max-choices",
   associationKey: "min-associations" | "max-associations",
 ): string | undefined {
+  if (interaction.type === "extendedText")
+    return interaction.attributes[choiceKey === "min-choices" ? "min-strings" : "max-strings"];
   if (interaction.type === "order" || interaction.type === "graphicOrder") {
     return interaction.attributes[choiceKey];
   }
@@ -42,7 +44,7 @@ function interactionRequiresResponse(interaction: QtiInteraction): boolean {
 }
 
 export function minimumRequiredResponses(interaction: QtiInteraction | undefined): number {
-  if (!interaction) return 1;
+  if (!interaction) return 0;
   if (interaction.type === "media") return minimumMediaPlays(interaction);
   const explicit = responseLimitAttribute(interaction, "min-choices", "min-associations");
   if (explicit === undefined) return interactionRequiresResponse(interaction) ? 1 : 0;
@@ -54,6 +56,10 @@ export function maximumAllowedResponses(
 ): number | undefined {
   if (!interaction) return undefined;
   if (interaction.type === "media") return maximumMediaPlays(interaction);
+  if (interaction.type === "extendedText") {
+    const maximum = interaction.attributes["max-strings"];
+    return maximum === undefined ? undefined : parseNonNegativeInteger(maximum);
+  }
   if (
     (interaction.type === "order" || interaction.type === "graphicOrder") &&
     !orderSubsetLimitsActive(interaction)
@@ -61,7 +67,32 @@ export function maximumAllowedResponses(
     return undefined;
   }
   const explicit = responseLimitAttribute(interaction, "max-choices", "max-associations");
-  if (explicit === undefined) return undefined;
+  if (explicit === undefined) {
+    switch (interaction.type) {
+      case "associate":
+      case "match":
+      case "gapMatch":
+      case "graphicAssociate":
+      case "graphicGapMatch":
+      case "choice":
+      case "hottext":
+      case "hotspot":
+      case "positionObject":
+        return 1;
+      case "custom":
+      case "drawing":
+      case "endAttempt":
+      case "graphicOrder":
+      case "inlineChoice":
+      case "order":
+      case "portableCustom":
+      case "selectPoint":
+      case "slider":
+      case "textEntry":
+      case "upload":
+        return undefined;
+    }
+  }
   const parsed = parseNonNegativeInteger(explicit);
   return parsed === undefined || parsed <= 0 ? undefined : parsed;
 }
@@ -90,6 +121,7 @@ export { maximumMediaPlays, minimumMediaPlays };
 export function responseValidationPolicy(
   declaration: { readonly correctResponse: QtiValue | null },
   interaction: QtiInteraction | undefined,
+  requireScoredResponses = false,
 ): QtiResponseValidationPolicy {
   const authoredMinimum =
     interaction === undefined
@@ -97,7 +129,7 @@ export function responseValidationPolicy(
       : responseLimitAttribute(interaction, "min-choices", "min-associations");
   const minimum = interaction === undefined ? undefined : minimumRequiredResponses(interaction);
   const validatesMinimum =
-    declaration.correctResponse !== null ||
+    (requireScoredResponses && declaration.correctResponse !== null) ||
     interaction?.type === "media" ||
     authoredMinimum !== undefined ||
     (minimum !== undefined && minimum > 0);
@@ -225,3 +257,39 @@ export function matchMaxDiagnostics(
   }
   return diagnostics;
 }
+
+/** Enforce authored per-choice minimum uses when a response is finalized. */
+export function matchMinDiagnostics(
+  responseIdentifier: string,
+  interaction: QtiInteraction,
+  response: QtiValue,
+): QtiDiagnostic[] {
+  if (
+    !["associate", "graphicAssociate", "match", "gapMatch", "graphicGapMatch"].includes(
+      interaction.type,
+    )
+  )
+    return [];
+  const pairs = qtiValueToIdentifierList(response);
+  const diagnostics: QtiDiagnostic[] = [];
+  for (const choice of interaction.choices) {
+    const minimum = parseNonNegativeInteger(choice.attributes["match-min"] ?? "0") ?? 0;
+    if (minimum === 0) continue;
+    const side =
+      choice.role === "matchSource" || choice.role === "gapChoice"
+        ? "source"
+        : choice.role === "matchTarget" ||
+            (interaction.type === "graphicGapMatch" && choice.role === "hotspot")
+          ? "target"
+          : "either";
+    if (directedPairChoiceUseCount(choice, pairs, side) >= minimum) continue;
+    diagnostics.push({
+      code: "response.matchMin",
+      severity: "error",
+      message: `${choice.text || choice.identifier} must be used at least ${minimum} time${minimum === 1 ? "" : "s"}.`,
+      path: responseIdentifier,
+      source: choice.source,
+    });
+  }
+  return diagnostics;
+}

package/src/response-validation.ts

@@ -8,11 +8,13 @@ import type {
   QtiScalarValue,
   QtiValue,
 } from "./types.js";
+import { isQtiTextResponseRecord, qtiTextResponseString } from "./text-response.js";
 import { assertNever } from "./assert-never.js";
 import { isNullResponse, isRecordValue, valueContainer } from "./processing-values.js";
 import { listNamedResponseInputs, type QtiNamedResponseInput } from "./response-input.js";
 import {
   matchMaxDiagnostics,
+  matchMinDiagnostics,
   maximumAllowedResponses,
   maximumResponseDiagnostic,
   mediaPlayCount,
@@ -33,6 +35,7 @@ export type QtiResponseValidationDiagnosticCode =
   | "response.required"
   | "response.maximum"
   | "response.matchMax"
+  | "response.matchMin"
   | "response.cardinality"
   | "response.baseType"
   | "response.domain"
@@ -65,6 +68,8 @@ export interface QtiResponseValidationInput {
   item: QtiAssessmentItem;
   responses: QtiResponseVariablesInput;
   allowIncompleteResponses?: boolean | undefined;
+  /** Host policy: require a scored response when no minimum is authored; defaults to false. */
+  requireScoredResponses?: boolean | undefined;
   allowedUndeclaredResponseIdentifiers?: readonly string[] | undefined;
   responseIdentifiers?: Iterable<string> | undefined;
 }
@@ -113,6 +118,17 @@ export function parseQtiResponseVariables(
       if (cardinalityMatches && parsedValue !== undefined) {
         responses.set(declaration.identifier, parsedValue);
         validateResponseDomain(declaration, interactions ?? [], parsedValue, diagnostics);
+        if (
+          declaration.cardinality === "record" &&
+          parsedValue !== null &&
+          interactions?.some(
+            (interaction) =>
+              interaction.type === "textEntry" || interaction.type === "extendedText",
+          ) &&
+          !isQtiTextResponseRecord(parsedValue)
+        ) {
+          pushResponseDomainDiagnostic(declaration, parsedValue, diagnostics);
+        }
       }
     }
 
@@ -122,6 +138,7 @@ export function parseQtiResponseVariables(
         undefined,
         value,
         input.allowIncompleteResponses,
+        input.requireScoredResponses,
         diagnostics,
       );
       continue;
@@ -133,6 +150,7 @@ export function parseQtiResponseVariables(
         interaction,
         value,
         input.allowIncompleteResponses,
+        input.requireScoredResponses,
         diagnostics,
       );
     }
@@ -379,17 +397,37 @@ function validateDeclarationResponse(
   interaction: QtiInteraction | undefined,
   value: QtiValue | undefined,
   allowIncompleteResponses: boolean | undefined,
+  requireScoredResponses: boolean | undefined,
   diagnostics: QtiResponseValidationDiagnostic[],
 ): void {
-  const policy = responseValidationPolicy(declaration, interaction);
+  if (interaction && !allowIncompleteResponses) {
+    diagnostics.push(
+      ...matchMinDiagnostics(declaration.identifier, interaction, value ?? null).map((diagnostic) =>
+        attachResponseIdentifier(declaration.identifier, diagnostic),
+      ),
+    );
+  }
+  const policy = responseValidationPolicy(declaration, interaction, requireScoredResponses);
   if (!policy.checkMinimum && !policy.checkMaximum && !policy.checkMatchMax) return;
 
   const effectiveValue = value ?? null;
   const count =
-    interaction?.type === "media" ? mediaPlayCount(effectiveValue) : responseCount(effectiveValue);
+    interaction?.type === "extendedText" || interaction?.type === "textEntry"
+      ? Array.isArray(effectiveValue)
+        ? effectiveValue.filter((entry) => entry !== "").length
+        : qtiTextResponseString(effectiveValue) === ""
+          ? 0
+          : 1
+      : interaction?.type === "media"
+        ? mediaPlayCount(effectiveValue)
+        : responseCount(effectiveValue);
 
   if (policy.checkMinimum && !allowIncompleteResponses) {
-    const minimum = effectiveMinimumRequiredResponses(declaration, interaction);
+    const minimum = effectiveMinimumRequiredResponses(
+      declaration,
+      interaction,
+      requireScoredResponses,
+    );
     if (count < minimum) {
       diagnostics.push(
         attachResponseIdentifier(
@@ -424,9 +462,15 @@ function validateDeclarationResponse(
 function effectiveMinimumRequiredResponses(
   declaration: { readonly correctResponse: QtiValue | null },
   interaction: QtiInteraction | undefined,
+  requireScoredResponses: boolean | undefined,
 ): number {
   const minimum = minimumRequiredResponses(interaction);
-  if (declaration.correctResponse === null || hasAuthoredMinimum(interaction)) return minimum;
+  if (
+    !requireScoredResponses ||
+    declaration.correctResponse === null ||
+    hasAuthoredMinimum(interaction)
+  )
+    return minimum;
   return Math.max(minimum, 1);
 }
 
@@ -453,6 +497,7 @@ function isResponseValidationDiagnosticCode(
     code === "response.required" ||
     code === "response.maximum" ||
     code === "response.matchMax" ||
+    code === "response.matchMin" ||
     code === "response.cardinality" ||
     code === "response.baseType" ||
     code === "response.domain" ||

package/src/scoring-disposition-policy.ts

@@ -1,5 +1,5 @@
 import type { QtiAssessmentItem } from "./types.js";
-import { itemExpectsAutomatedScore } from "./item-scoring-expectation.js";
+import { itemExpectsAutomatedScore, itemHasExternalScore } from "./item-scoring-expectation.js";
 
 export type QtiItemSubmissionScoringDisposition =
   | "scored"
@@ -23,7 +23,11 @@ export function itemHasManuallyScoredInteractions(item: QtiAssessmentItem): bool
 }
 
 export function itemNeedsScoringFollowUpWhenUnscored(item: QtiAssessmentItem): boolean {
-  return itemExpectsAutomatedScore(item) || itemHasManuallyScoredInteractions(item);
+  return (
+    itemHasExternalScore(item) ||
+    itemExpectsAutomatedScore(item) ||
+    itemHasManuallyScoredInteractions(item)
+  );
 }
 
 /** Default generic disposition taxonomy shipped by qti3-core for submission materialization. */
@@ -31,6 +35,7 @@ export function classifyQtiItemScoringDisposition(
   item: QtiAssessmentItem,
   score: number | null,
 ): Exclude<QtiItemSubmissionScoringDisposition, "invalid"> {
+  if (itemHasExternalScore(item)) return "manual-scoring-required";
   if (score !== null) return "scored";
   if (itemNeedsScoringFollowUpWhenUnscored(item)) return "manual-scoring-required";
   return "unscored-reference";