@playcademy/vite-plugin 1.2.1-beta.11 → 1.2.1-beta.13

package/dist/index.js

@@ -24315,7 +24315,7 @@ import path2 from "node:path";
 // package.json
 var package_default = {
   name: "@playcademy/vite-plugin",
-  version: "1.2.1-beta.11",
+  version: "1.2.1-beta.13",
   type: "module",
   exports: {
     ".": {
@@ -25921,7 +25921,7 @@ var package_default2;
 var init_package = __esm(() => {
   package_default2 = {
     name: "@playcademy/sandbox",
-    version: "0.7.1-beta.11",
+    version: "0.7.1-beta.13",
     description: "Local development server for Playcademy game development",
     type: "module",
     exports: {
@@ -34173,6 +34173,23 @@ var init_v3 = __esm(() => {
 var init_esm = __esm(() => {
   init_v3();
 });
+function qtiDirectedPairValidationIssue(values, contract) {
+  const sourceCounts = new Map;
+  const targetCounts = new Map;
+  for (const value of values) {
+    const [source, target, extra] = value.split(" ");
+    if (extra !== undefined || !source || !target || !contract.sources.has(source) || !contract.targets.has(target)) {
+      return { kind: "invalid-pair", value };
+    }
+    if (!withinQtiCapacity(contract.sources, sourceCounts, source)) {
+      return { kind: "source-capacity", identifier: source };
+    }
+    if (!withinQtiCapacity(contract.targets, targetCounts, target)) {
+      return { kind: "target-capacity", identifier: target };
+    }
+  }
+  return null;
+}
 function isRecord2(value) {
   return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
@@ -34475,19 +34492,15 @@ function assessmentResponseValidationMessage(assessment, responses) {
   return null;
 }
 function directedPairsValidationMessage(itemIdentifier, values, contract) {
-  const sourceCounts = new Map;
-  const targetCounts = new Map;
-  for (const value of values) {
-    const [source, target, extra] = value.split(" ");
-    if (extra !== undefined || !source || !target || !contract.sources.has(source) || !contract.targets.has(target)) {
+  const issue = qtiDirectedPairValidationIssue(values, contract);
+  if (issue) {
+    if (issue.kind === "invalid-pair") {
       return `Response for ${itemIdentifier} contains an invalid association pair.`;
     }
-    if (!withinQtiCapacity(contract.sources, sourceCounts, source)) {
+    if (issue.kind === "source-capacity") {
       return `Response for ${itemIdentifier} uses a token beyond its allowed placements.`;
     }
-    if (!withinQtiCapacity(contract.targets, targetCounts, target)) {
-      return `Response for ${itemIdentifier} fills a target beyond its capacity.`;
-    }
+    return `Response for ${itemIdentifier} fills a target beyond its capacity.`;
   }
   return null;
 }
@@ -34567,8 +34580,14 @@ function interactionResponseValidationMessage(itemIdentifier, interaction, respo
     allowed = new Set(interaction.choices.map((candidate) => candidate.identifier));
   } else if (interaction.type === "match") {
     const message = directedPairsValidationMessage(itemIdentifier, values, {
-      sources: new Map(interaction.sourceChoices.map((candidate) => [candidate.identifier, 0])),
-      targets: new Map(interaction.targetChoices.map((candidate) => [candidate.identifier, 0]))
+      sources: new Map(interaction.sourceChoices.map((candidate) => [
+        candidate.identifier,
+        candidate.matchMax
+      ])),
+      targets: new Map(interaction.targetChoices.map((candidate) => [
+        candidate.identifier,
+        candidate.matchMax
+      ]))
     });
     if (message) {
       return message;
@@ -35354,6 +35373,7 @@ var init_assessment_runtime = __esm(() => {
   init_fxp();
   init_timeback3();
   init_timeback3();
+  init_timeback3();
   init_src();
   init_timeback3();
   init_src();
@@ -112256,18 +112276,18 @@ function serializeSanitizedMathMl(node) {
   const children = node.children.map(serializeSanitizedMathMl).join("");
   return `<${node.localName}${attributes2}>${children}</${node.localName}>`;
 }
-function tableContentNode(element, blankForInteraction) {
+function tableContentNode(element, blankForInteraction, gapForElement) {
   const rows = xmlDescendants(element, (candidate) => candidate.localName === "tr").map((row) => {
     const cells = row.children.filter((cell) => cell.kind === "element" && (cell.localName === "td" || cell.localName === "th"));
     return {
       header: cells.length > 0 && cells.every((cell) => cell.localName === "th"),
-      cells: cells.map((cell) => contentNodesFrom(cell.children, blankForInteraction))
+      cells: cells.map((cell) => contentNodesFrom(cell.children, blankForInteraction, gapForElement))
     };
   });
   return { kind: "table", rows };
 }
-function listContentNode(element, blankForInteraction) {
-  const items = element.children.filter((child) => child.kind === "element" && child.localName === "li").map((item) => contentNodesFrom(item.children, blankForInteraction));
+function listContentNode(element, blankForInteraction, gapForElement) {
+  const items = element.children.filter((child) => child.kind === "element" && child.localName === "li").map((item) => contentNodesFrom(item.children, blankForInteraction, gapForElement));
   return { kind: "list", ordered: element.localName === "ol", items };
 }
 function contentText(raw) {
@@ -112292,15 +112312,18 @@ function trimContentBoundaries(nodes) {
   }
   return kept.filter((node) => node.kind !== "text" || node.text !== "");
 }
-function collectContentNodes(nodes, blankForInteraction) {
+function collectContentNodes(nodes, blankForInteraction, gapForElement) {
   const result = [];
   for (const node of nodes) {
+    const gapIdentifier = node.kind === "element" ? gapForElement(node) : null;
     if (node.kind === "text") {
       const text3 = contentText(node.value);
       if (text3) {
         result.push({ kind: "text", text: text3 });
       }
-    } else if (CONTENT_SKIPPED_TAGS2.has(node.localName)) {} else if (isInteractionElement(node)) {
+    } else if (CONTENT_SKIPPED_TAGS2.has(node.localName)) {} else if (gapIdentifier !== null) {
+      result.push({ kind: "gap", identifier: gapIdentifier });
+    } else if (isInteractionElement(node)) {
       const responseIdentifier = blankForInteraction(node);
       if (responseIdentifier) {
         result.push({ kind: "blank", responseIdentifier });
@@ -112325,19 +112348,19 @@ function collectContentNodes(nodes, blankForInteraction) {
         });
       }
     } else if (node.localName === "table") {
-      result.push(tableContentNode(node, blankForInteraction));
+      result.push(tableContentNode(node, blankForInteraction, gapForElement));
     } else if (node.localName === "ul" || node.localName === "ol") {
-      const list = listContentNode(node, blankForInteraction);
+      const list = listContentNode(node, blankForInteraction, gapForElement);
       if (list.kind === "list" && list.items.length > 0) {
         result.push(list);
       }
     } else if (node.localName === "p") {
-      const children = contentNodesFrom(node.children, blankForInteraction);
+      const children = contentNodesFrom(node.children, blankForInteraction, gapForElement);
       if (children.length > 0) {
         result.push({ kind: "paragraph", children });
       }
     } else if (EMPHASIS_TAGS2.has(node.localName) || STRONG_TAGS2.has(node.localName)) {
-      const children = collectContentNodes(node.children, blankForInteraction);
+      const children = collectContentNodes(node.children, blankForInteraction, gapForElement);
       const hasContent = children.some((child) => child.kind !== "text" || Boolean(child.text.trim()));
       if (hasContent) {
         result.push({
@@ -112346,17 +112369,17 @@ function collectContentNodes(nodes, blankForInteraction) {
         });
       }
     } else {
-      result.push(...collectContentNodes(node.children, blankForInteraction));
+      result.push(...collectContentNodes(node.children, blankForInteraction, gapForElement));
     }
   }
   return result;
 }
-function contentNodesFrom(nodes, blankForInteraction) {
-  return trimContentBoundaries(collectContentNodes(nodes, blankForInteraction));
+function contentNodesFrom(nodes, blankForInteraction, gapForElement = () => null) {
+  return trimContentBoundaries(collectContentNodes(nodes, blankForInteraction, gapForElement));
 }
 function hasRichContent(nodes) {
   return nodes.some((node) => {
-    if (node.kind === "math" || node.kind === "image" || node.kind === "table" || node.kind === "list" || node.kind === "blank") {
+    if (node.kind === "math" || node.kind === "image" || node.kind === "table" || node.kind === "list" || node.kind === "blank" || node.kind === "gap") {
       return true;
     }
     if (node.kind === "paragraph" || node.kind === "emphasis" || node.kind === "strong") {
@@ -112377,7 +112400,14 @@ function parseGapMatchText(interaction) {
     }
     return GAP_MATCH_TOKEN_TAGS2.has(element.localName) ? "" : undefined;
   });
-  return { textWithGaps, gaps };
+  const passageNodes = interaction.children.filter((node) => node.kind === "text" || !GAP_MATCH_TOKEN_TAGS2.has(node.localName));
+  const gapContent = contentNodesFrom(passageNodes, () => null, (element) => {
+    if (element.localName !== "qti-gap") {
+      return null;
+    }
+    return parseXmlAttributes(element.attributes).identifier ?? null;
+  });
+  return { textWithGaps, gaps, gapContent };
 }
 function isInlineInteractionElement(element) {
   const type = INTERACTION_TYPES2[element.localName];
@@ -112404,6 +112434,7 @@ function parseInteraction(source, interaction, context2) {
   let gapImages = [];
   let gaps = [];
   let textWithGaps;
+  let gapContent;
   function ownStageGraphic() {
     return firstGraphic(interaction, STAGE_GRAPHIC_EXCLUDED_CONTAINERS2);
   }
@@ -112425,7 +112456,7 @@ function parseInteraction(source, interaction, context2) {
     graphic = ownStageGraphic();
   } else if (type === "gap-match") {
     gapTexts = parseGapTexts(interaction);
-    ({ textWithGaps, gaps } = parseGapMatchText(interaction));
+    ({ textWithGaps, gaps, gapContent } = parseGapMatchText(interaction));
   } else if (type === "graphic-gap-match") {
     graphic = ownStageGraphic();
     gapImages = parseGapImages(interaction);
@@ -112453,6 +112484,7 @@ function parseInteraction(source, interaction, context2) {
     gapImages,
     gaps,
     ...textWithGaps === undefined ? {} : { textWithGaps },
+    ...gapContent === undefined ? {} : { gapContent },
     rawXml: xmlElementSource(source, interaction)
   };
 }
@@ -112543,6 +112575,23 @@ function parseQtiItemXml(rawXml) {
     rawXml
   };
 }
+function qtiDirectedPairValidationIssue2(values, contract) {
+  const sourceCounts = new Map;
+  const targetCounts = new Map;
+  for (const value of values) {
+    const [source, target, extra] = value.split(" ");
+    if (extra !== undefined || !source || !target || !contract.sources.has(source) || !contract.targets.has(target)) {
+      return { kind: "invalid-pair", value };
+    }
+    if (!withinQtiCapacity(contract.sources, sourceCounts, source)) {
+      return { kind: "source-capacity", identifier: source };
+    }
+    if (!withinQtiCapacity(contract.targets, targetCounts, target)) {
+      return { kind: "target-capacity", identifier: target };
+    }
+  }
+  return null;
+}
 function usableQtiRegionGeometry(shape, coords) {
   const arity2 = REGION_SHAPE_COORDS[shape];
   if (!arity2) {
@@ -113007,6 +113056,17 @@ function interactionBody(item, node, type, declaration, attributes2) {
     if (!attributes2.has("max-associations")) {
       attributes2.set("max-associations", String(correctValueStrings(declaration).length || sources.length));
     }
+    const capacityIssue = qtiDirectedPairValidationIssue2(correctValueStrings(declaration), {
+      sources: new Map(sources.map((choice) => [choice.identifier, 1])),
+      targets: new Map(targets.map((choice) => [choice.identifier, 1]))
+    });
+    if (capacityIssue) {
+      if (capacityIssue.kind === "invalid-pair") {
+        compileError(`Match pair “${capacityIssue.value}” must name one declared source and target choice`);
+      }
+      const role = capacityIssue.kind === "source-capacity" ? "Source" : "Target";
+      compileError(`${role} “${capacityIssue.identifier}” takes part in more associations than its match-max allows`);
+    }
     const sets = [sources, targets].map((choices) => `<qti-simple-match-set>${choices.map((choice) => choiceXml(item, "qti-simple-associable-choice", choice, {
       "match-max": "1"
     })).join("")}</qti-simple-match-set>`).join("");
@@ -113292,6 +113352,14 @@ function qtiAttributeNumber(attributes2, name3, fallback) {
   const value = Number(raw);
   return Number.isFinite(value) ? value : fallback;
 }
+function qtiAttributeCapacity(attributes2, name3, fallback) {
+  const raw = attributes2[name3]?.trim();
+  if (!raw) {
+    return fallback;
+  }
+  const value = Number(raw);
+  return Number.isInteger(value) && value >= 0 ? value : null;
+}
 function qtiAttributeMaximum(attributes2, name3, fallback, unlimited) {
   const maximum = qtiAttributeNumber(attributes2, name3, fallback);
   return maximum === 0 ? unlimited : maximum;
@@ -113300,6 +113368,27 @@ function qtiAttributeBoolean(attributes2, name3) {
   const value = attributes2[name3];
   return value === "true" || value === "1";
 }
+function gapContentIdentifiers(nodes) {
+  return nodes.flatMap((node) => {
+    if (node.kind === "gap") {
+      return [node.identifier];
+    }
+    if (node.kind === "paragraph" || node.kind === "emphasis" || node.kind === "strong") {
+      return gapContentIdentifiers(node.children);
+    }
+    if (node.kind === "list") {
+      return node.items.flatMap(gapContentIdentifiers);
+    }
+    if (node.kind === "table") {
+      return node.rows.flatMap((row) => row.cells.flatMap(gapContentIdentifiers));
+    }
+    return [];
+  });
+}
+function qtiGapContentMatchesGaps(nodes, gaps) {
+  const identifiers = gapContentIdentifiers(nodes);
+  return identifiers.length === gaps.length && identifiers.every((identifier, index2) => identifier === gaps[index2]);
+}
 function normalizedInteractionType(value) {
   if (typeof value !== "string") {
     return;
@@ -113310,6 +113399,9 @@ function normalizedInteractionType(value) {
 function usableChoices(choices) {
   return choices !== undefined && choices.length > 0 && choices.every((choice) => Boolean(choice.identifier));
 }
+function usableAssociableChoices(choices) {
+  return usableChoices(choices) && choices.every((choice) => qtiAttributeCapacity(choice.attributes, "match-max", 0) !== null);
+}
 function transportableIdentifiers(identifiers) {
   return identifiers.every((identifier) => Boolean(identifier) && !/\s/.test(identifier));
 }
@@ -113382,7 +113474,7 @@ function authorableQtiInteractionProjection(interaction) {
     }
     case "match": {
       const [sourceChoices, targetChoices] = interaction.choiceSets;
-      if (interaction.choiceSets.length !== 2 || !usableChoices(sourceChoices) || !usableChoices(targetChoices) || !transportableIdentifiers([...sourceChoices, ...targetChoices].map((choice) => choice.identifier))) {
+      if (interaction.choiceSets.length !== 2 || !usableAssociableChoices(sourceChoices) || !usableAssociableChoices(targetChoices) || !transportableIdentifiers([...sourceChoices, ...targetChoices].map((choice) => choice.identifier))) {
         return null;
       }
       return {
@@ -113451,8 +113543,8 @@ function authorableQtiInteractionProjection(interaction) {
       };
     }
     case "gap-match": {
-      const { gapTexts, gaps, textWithGaps } = interaction;
-      if (gapTexts.length === 0 || gaps.length === 0 || textWithGaps === undefined || !gapTexts.every((gapText) => Boolean(gapText.identifier && gapText.content)) || !transportableIdentifiers([...gapTexts.map((gapText) => gapText.identifier), ...gaps])) {
+      const { gapTexts, gaps, textWithGaps, gapContent } = interaction;
+      if (gapTexts.length === 0 || gaps.length === 0 || textWithGaps === undefined || !gapContent || !qtiGapContentMatchesGaps(gapContent, gaps) || !gapTexts.every((gapText) => Boolean(gapText.identifier && gapText.content)) || !transportableIdentifiers([...gapTexts.map((gapText) => gapText.identifier), ...gaps])) {
         return null;
       }
       return {
@@ -113461,6 +113553,7 @@ function authorableQtiInteractionProjection(interaction) {
         gapTexts,
         gaps,
         textWithGaps,
+        gapContent,
         shuffle: qtiAttributeBoolean(attributes2, "shuffle")
       };
     }
@@ -113484,7 +113577,7 @@ function contributesScore(declaration) {
 function responsePairs(left, right) {
   return left.flatMap((first) => right.map((second) => `${first} ${second}`));
 }
-function mappingResponseContext(item, declaration) {
+function interactionResponseSpace(item, declaration) {
   const interaction = item.interactions.find((candidate) => candidate.responseIdentifier === declaration.identifier);
   if (!interaction) {
     return {};
@@ -113576,21 +113669,49 @@ function processesResponseMapping(item, declaration) {
   }
   return item.responseProcessing.elements.some((element) => element.tagName === "qti-map-response" && (element.attributes.identifier ?? "RESPONSE") === declaration.identifier);
 }
-function responseMappingMaximum(item, declaration) {
+function responseMappingMaximum(item, declaration, space) {
   if (!declaration.mapping || !processesResponseMapping(item, declaration)) {
     return null;
   }
   return qtiResponseMappingMaximum({
     cardinality: declaration.cardinality,
     mapping: declaration.mapping,
-    ...mappingResponseContext(item, declaration)
+    ...space ?? interactionResponseSpace(item, declaration)
   });
 }
 function qtiItemScoringValidationMessage(item) {
   for (const declaration of item.responseDeclarations) {
+    const space = interactionResponseSpace(item, declaration);
+    const { responseValues: responseValues2, maximumResponses } = space;
+    if (responseValues2 && declaration.correctValues.some((value) => !responseValues2.includes(value))) {
+      return `Response ${declaration.identifier} declares a correct value its interaction cannot produce.`;
+    }
+    const interaction = item.interactions.find((candidate) => candidate.responseIdentifier === declaration.identifier);
+    if (interaction?.type === "match") {
+      const [sources = [], targets = []] = interaction.choiceSets;
+      const issue6 = qtiDirectedPairValidationIssue2(declaration.correctValues, {
+        sources: new Map(sources.map((choice) => [
+          choice.identifier,
+          qtiAttributeNumber(choice.attributes, "match-max", 0)
+        ])),
+        targets: new Map(targets.map((choice) => [
+          choice.identifier,
+          qtiAttributeNumber(choice.attributes, "match-max", 0)
+        ]))
+      });
+      if (issue6?.kind === "source-capacity") {
+        return `Response ${declaration.identifier} declares correct pairs that exceed source ${issue6.identifier}'s match-max.`;
+      }
+      if (issue6?.kind === "target-capacity") {
+        return `Response ${declaration.identifier} declares correct pairs that exceed target ${issue6.identifier}'s match-max.`;
+      }
+    }
+    if (declaration.cardinality !== "single" && maximumResponses !== undefined && maximumResponses !== 0 && declaration.correctValues.length > maximumResponses) {
+      return `Response ${declaration.identifier} declares more correct values than its interaction accepts.`;
+    }
     if (declaration.mapping) {
       if (processesResponseMapping(item, declaration)) {
-        if (responseMappingMaximum(item, declaration) === null) {
+        if (responseMappingMaximum(item, declaration, space) === null) {
           return `Response ${declaration.identifier} has a mapping with no reachable positive score.`;
         }
       } else if (declaration.correctValues.length === 0) {
@@ -113960,6 +114081,7 @@ var init_qti = __esm(() => {
   init_fxp();
   init_timeback3();
   init_timeback3();
+  init_timeback3();
   EVENT_HANDLER_ATTRIBUTE = /^on/i;
   SCRIPT_SCHEMES2 = {
     javascript: ["java", "script:"].join(""),
@@ -116786,6 +116908,16 @@ function playableChoice(choice) {
     ...choice.contentNodes ? { contentNodes: choice.contentNodes } : {}
   };
 }
+function playableAssociableChoice(choice) {
+  const matchMax = qtiAttributeCapacity(choice.attributes, "match-max", 0);
+  if (matchMax === null) {
+    throw new AssessmentRuntimeError("UNSUPPORTED_INTERACTION", "The selected assessment contains an invalid Match capacity.");
+  }
+  return {
+    ...playableChoice(choice),
+    matchMax
+  };
+}
 function requireChoices2(choices) {
   if (choices.length === 0 || choices.some((candidate) => !candidate.identifier)) {
     throw new AssessmentRuntimeError("UNSUPPORTED_INTERACTION", "The selected assessment contains an interaction Playcademy cannot render.");
@@ -116871,8 +117003,8 @@ function parseInteraction2(questionIdentifier, interaction) {
     if (sets.length !== 2) {
       throw new AssessmentRuntimeError("UNSUPPORTED_INTERACTION", "Match interactions require exactly two choice sets.");
     }
-    const sourceChoices = requireChoices2(sets[0].map(playableChoice));
-    const targetChoices = requireChoices2(sets[1].map(playableChoice));
+    const sourceChoices = requireChoices2(sets[0].map(playableAssociableChoice));
+    const targetChoices = requireChoices2(sets[1].map(playableAssociableChoice));
     return {
       type,
       responseIdentifier,
@@ -116897,7 +117029,7 @@ function parseInteraction2(questionIdentifier, interaction) {
     };
   }
   if (type === "gap-match") {
-    if (interaction.gapTexts.length === 0 || interaction.gaps.length === 0 || interaction.textWithGaps === undefined) {
+    if (interaction.gapTexts.length === 0 || interaction.gaps.length === 0 || interaction.textWithGaps === undefined || !interaction.gapContent || !qtiGapContentMatchesGaps(interaction.gapContent, interaction.gaps)) {
       throw new AssessmentRuntimeError("UNSUPPORTED_INTERACTION", `Assessment item ${questionIdentifier} has an incomplete gap-match interaction.`);
     }
     return {
@@ -116905,6 +117037,7 @@ function parseInteraction2(questionIdentifier, interaction) {
       responseIdentifier,
       ...prompt,
       content: interaction.textWithGaps,
+      contentNodes: interaction.gapContent,
       gapTexts: interaction.gapTexts.map((gapText) => ({
         identifier: gapText.identifier,
         content: gapText.content,
@@ -119009,8 +119142,7 @@ function assertPlayableQtiQuestion(question) {
   }
   const item = parsedQtiItemOrNull(question.rawXml);
   const playable = item && playableQtiInteractions(item);
-  const scoringIssue = item && qtiItemScoringValidationMessage(item);
-  if (!playable || scoringIssue) {
+  if (!playable || qtiItemScoringValidationMessage(item)) {
     throw new ValidationError(`Question ${question.identifier} uses an interaction Playcademy cannot play or score.`);
   }
 }
@@ -119263,31 +119395,38 @@ ${input.itemBody}
   </qti-response-processing>
 </qti-assessment-item>`;
 }
-function parseInlineChoices(value) {
-  if (!Array.isArray(value) || value.length < 2) {
-    throw new ValidationError("Inline-choice questions require at least two choices");
+function parseStructuredChoices(value, options) {
+  const { label, minimum, validate: validate2 } = options;
+  if (!Array.isArray(value) || value.length < minimum) {
+    throw new ValidationError(`${label} questions require at least ${minimum === 1 ? "one choice" : `${minimum} choices`}`);
   }
   const choices = value.map((choice) => {
     const record3 = recordValue(choice);
     const identifier = record3?.identifier;
     const content = record3?.content;
-    if (typeof identifier !== "string" || !identifier.trim() || typeof content !== "string" || !content.trim()) {
-      throw new ValidationError("Inline-choice options are invalid");
+    if (typeof identifier !== "string" || !identifier.trim() || typeof content !== "string" || !content.trim() || validate2 !== undefined && record3 !== undefined && !validate2(record3)) {
+      throw new ValidationError(`${label} options are invalid`);
     }
     return { identifier: identifier.trim(), content: content.trim() };
   });
   if (new Set(choices.map((choice) => choice.identifier)).size !== choices.length) {
-    throw new ValidationError("Inline-choice option identifiers must be unique");
+    throw new ValidationError(`${label} option identifiers must be unique`);
   }
   return choices;
 }
-function inlineChoiceCorrectIdentifier(input, responseIdentifier, choiceIdentifiers) {
+function declaredCorrectResponse(input, responseIdentifier) {
   const declarations = Array.isArray(input.responseDeclarations) ? input.responseDeclarations : [];
   const declaration = declarations.map(recordValue).find((candidate) => candidate?.identifier === responseIdentifier);
-  const correctResponse = recordValue(declaration?.correctResponse);
-  const rawValues = correctResponse?.value;
-  const values = Array.isArray(rawValues) ? rawValues.filter((value) => typeof value === "string") : [];
-  if (declaration?.cardinality !== "single" || declaration.baseType !== "identifier") {
+  const rawValues = recordValue(declaration?.correctResponse)?.value;
+  return {
+    cardinality: declaration?.cardinality,
+    baseType: declaration?.baseType,
+    values: Array.isArray(rawValues) ? rawValues.filter((value) => typeof value === "string") : []
+  };
+}
+function inlineChoiceCorrectIdentifier(input, responseIdentifier, choiceIdentifiers) {
+  const { cardinality, baseType, values } = declaredCorrectResponse(input, responseIdentifier);
+  if (cardinality !== "single" || baseType !== "identifier") {
     throw new ValidationError("Inline-choice questions require a single-identifier response declaration");
   }
   if (values.length !== 1 || !choiceIdentifiers.has(values[0])) {
@@ -119295,27 +119434,41 @@ function inlineChoiceCorrectIdentifier(input, responseIdentifier, choiceIdentifi
   }
   return values[0];
 }
-function buildInlineChoiceQuestionXml(input, identifier, title) {
+function structuredQuestionEnvelope(input, type, label, title) {
   const interaction = recordValue(input.interaction);
-  const interactionType = normalizedQtiInteractionType(interaction?.type ?? input.type);
-  if (interactionType !== "inline-choice") {
+  if (normalizedQtiInteractionType(interaction?.type ?? input.type) !== type) {
     return null;
   }
-  const responseIdentifier = interaction?.responseIdentifier;
   const structure = recordValue(interaction?.questionStructure);
+  const responseIdentifier = interaction?.responseIdentifier;
   const prompt = structure?.prompt;
-  if (!structure || typeof responseIdentifier !== "string" || !responseIdentifier.trim()) {
-    throw new ValidationError("Inline-choice question data is invalid");
+  if (!interaction || !structure || typeof responseIdentifier !== "string" || !responseIdentifier.trim()) {
+    throw new ValidationError(`${label} question data is invalid`);
   }
   if (!title || typeof prompt !== "string" || !prompt.trim()) {
-    throw new ValidationError("Inline-choice questions require a title and prompt");
+    throw new ValidationError(`${label} questions require a title and prompt`);
+  }
+  return {
+    interaction,
+    structure,
+    responseIdentifier: responseIdentifier.trim(),
+    prompt: prompt.trim()
+  };
+}
+function buildInlineChoiceQuestionXml(input, identifier, title) {
+  const envelope = structuredQuestionEnvelope(input, "inline-choice", "Inline-choice", title);
+  if (!envelope) {
+    return null;
   }
-  const normalizedPrompt = prompt.trim();
-  const promptParts = normalizedPrompt.split(INLINE_CHOICE_BLANK);
+  const { structure, responseIdentifier, prompt } = envelope;
+  const promptParts = prompt.split(INLINE_CHOICE_BLANK);
   if (promptParts.length !== 2) {
     throw new ValidationError("Inline-choice questions require exactly one blank");
   }
-  const choices = parseInlineChoices(structure.inlineChoices);
+  const choices = parseStructuredChoices(structure.inlineChoices, {
+    label: "Inline-choice",
+    minimum: 2
+  });
   const choiceIdentifiers = new Set(choices.map((choice) => choice.identifier));
   const correctIdentifier = inlineChoiceCorrectIdentifier(input, responseIdentifier, choiceIdentifiers);
   const choicesXml = choices.map((choice) => `        <qti-inline-choice identifier="${escapeXml(choice.identifier)}">${escapeXml(choice.content)}</qti-inline-choice>`).join(`
@@ -119333,6 +119486,86 @@ ${choicesXml}
     itemBody
   });
 }
+function parseStructuredMatchChoices(value, label) {
+  return parseStructuredChoices(value, {
+    label: `Match ${label}`,
+    minimum: 1,
+    validate: (choice) => choice.matchMax === 1
+  });
+}
+function structuredMatchCorrectPairs(input, responseIdentifier, sources, targets) {
+  const { cardinality, baseType, values } = declaredCorrectResponse(input, responseIdentifier);
+  if (cardinality !== "multiple" || baseType !== "directedPair") {
+    throw new ValidationError("Match questions require a multiple directed-pair response declaration");
+  }
+  const sourceIdentifiers = new Set(sources.map((choice) => choice.identifier));
+  const targetIdentifiers = new Set(targets.map((choice) => choice.identifier));
+  const valid = values.length > 0 && new Set(values).size === values.length && values.every((value) => {
+    const [source, target, extra] = value.split(" ");
+    return extra === undefined && Boolean(source && target) && sourceIdentifiers.has(source) && targetIdentifiers.has(target);
+  });
+  if (!valid) {
+    throw new ValidationError("Every Match correct response must name one declared source and target choice");
+  }
+  return values;
+}
+function buildMatchQuestionXml(input, identifier, title) {
+  const envelope = structuredQuestionEnvelope(input, "match", "Match", title);
+  if (!envelope) {
+    return null;
+  }
+  const { interaction, structure, responseIdentifier, prompt } = envelope;
+  const sources = parseStructuredMatchChoices(structure.sourceChoices, "source");
+  const targets = parseStructuredMatchChoices(structure.targetChoices, "target");
+  const sourceIdentifiers = new Set(sources.map((choice) => choice.identifier));
+  if (targets.some((choice) => sourceIdentifiers.has(choice.identifier))) {
+    throw new ValidationError("Match source and target choice identifiers must be unique");
+  }
+  const correctValues = structuredMatchCorrectPairs(input, responseIdentifier, sources, targets);
+  const maxAssociations = interaction.maxAssociations;
+  if (typeof maxAssociations !== "number" || !Number.isInteger(maxAssociations) || maxAssociations < 0 || maxAssociations !== 0 && maxAssociations < correctValues.length) {
+    throw new ValidationError("Match max associations must fit every correct pair");
+  }
+  const item = {
+    key: identifier,
+    title,
+    body: [
+      {
+        kind: "interaction",
+        type: "match",
+        responseIdentifier,
+        attributes: {
+          shuffle: interaction.shuffle === true,
+          "max-associations": maxAssociations
+        },
+        content: [
+          {
+            kind: "element",
+            name: "qti-prompt",
+            children: [{ kind: "text", text: prompt }]
+          }
+        ],
+        choiceSets: [sources, targets].map((choices) => choices.map((choice) => ({
+          identifier: choice.identifier,
+          content: [{ kind: "text", text: choice.content }]
+        })))
+      }
+    ],
+    responseDeclarations: [
+      {
+        identifier: responseIdentifier,
+        cardinality: "multiple",
+        baseType: "directedPair",
+        correctValues
+      }
+    ]
+  };
+  try {
+    return compileQtiAuthoringItemXml(item, { identifier, title });
+  } catch (error88) {
+    throw new ValidationError(`This Match question cannot be compiled to QTI: ${errorMessage2(error88)}`);
+  }
+}
 function parseHottextSegments2(value) {
   if (!Array.isArray(value) || value.length === 0) {
     throw new ValidationError("Hottext questions require passage segments");
@@ -119637,7 +119870,8 @@ var init_timeback_qti_authoring_util = __esm(() => {
     buildNumericQuestionXml,
     buildAuthoringDocumentQuestionXml,
     buildHottextQuestionXml,
-    buildInlineChoiceQuestionXml
+    buildInlineChoiceQuestionXml,
+    buildMatchQuestionXml
   ];
 });
 function newPlaycademyTestIdentifier() {

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@playcademy/vite-plugin",
-    "version": "1.2.1-beta.11",
+    "version": "1.2.1-beta.13",
     "type": "module",
     "exports": {
         ".": {
@@ -19,14 +19,14 @@
     "dependencies": {
         "archiver": "^7.0.1",
         "picocolors": "^1.1.1",
-        "playcademy": "0.28.1-beta.11"
+        "playcademy": "0.28.1-beta.13"
     },
     "devDependencies": {
         "@electric-sql/pglite": "^0.3.16",
         "@inquirer/prompts": "^7.8.6",
         "@playcademy/constants": "0.0.1",
-        "@playcademy/sandbox": "0.7.1-beta.11",
-        "@playcademy/sdk": "0.16.1-beta.11",
+        "@playcademy/sandbox": "0.7.1-beta.13",
+        "@playcademy/sdk": "0.16.1-beta.13",
         "@playcademy/types": "0.0.1",
         "@playcademy/utils": "0.0.1",
         "@types/archiver": "^6.0.3",