@conform-ed/qti-react 0.0.12 → 0.0.14

package/dist/index.js

@@ -1,5 +1,26 @@
 // src/content-model.ts
-var v0InteractionKinds = ["choiceInteraction", "textEntryInteraction", "inlineChoiceInteraction"];
+var v0InteractionKinds = [
+  "associateInteraction",
+  "choiceInteraction",
+  "drawingInteraction",
+  "endAttemptInteraction",
+  "extendedTextInteraction",
+  "gapMatchInteraction",
+  "graphicAssociateInteraction",
+  "graphicGapMatchInteraction",
+  "graphicOrderInteraction",
+  "hotspotInteraction",
+  "hottextInteraction",
+  "inlineChoiceInteraction",
+  "matchInteraction",
+  "mediaInteraction",
+  "orderInteraction",
+  "positionObjectStage",
+  "selectPointInteraction",
+  "sliderInteraction",
+  "textEntryInteraction",
+  "uploadInteraction"
+];
 var v0FlowElements = new Set([
   "p",
   "span",
@@ -7,21 +28,62 @@ var v0FlowElements = new Set([
   "em",
   "b",
   "i",
+  "sub",
+  "sup",
   "br",
   "ul",
   "ol",
   "li",
   "ruby",
+  "rb",
   "rt",
-  "rp"
+  "rp",
+  "img",
+  "audio",
+  "video",
+  "source",
+  "track",
+  "picture",
+  "figure",
+  "figcaption",
+  "object",
+  "div",
+  "section",
+  "h1",
+  "h2",
+  "h3",
+  "h4",
+  "h5",
+  "h6",
+  "blockquote",
+  "hr",
+  "table",
+  "caption",
+  "thead",
+  "tbody",
+  "tfoot",
+  "tr",
+  "th",
+  "td"
+]);
+var v0ElementAttributes = new Map([
+  ["img", new Set(["src", "alt", "width", "height"])],
+  ["audio", new Set(["src", "controls", "loop", "muted", "preload"])],
+  ["video", new Set(["src", "controls", "loop", "muted", "preload", "poster", "width", "height"])],
+  ["source", new Set(["src", "type"])],
+  ["track", new Set(["src", "kind", "srclang", "label", "default"])],
+  ["object", new Set(["data", "type", "width", "height"])]
 ]);
+var v0UrlAttributes = new Set(["src", "poster", "data"]);
 var v0MathRoot = "math";
 var v0GlobalAttributes = new Set(["id", "class", "lang", "xml:lang", "dir"]);
 var v0ContentModel = {
   interactionKinds: new Set(v0InteractionKinds),
   flowElements: v0FlowElements,
   mathRoot: v0MathRoot,
-  globalAttributes: v0GlobalAttributes
+  globalAttributes: v0GlobalAttributes,
+  elementAttributes: v0ElementAttributes,
+  urlAttributes: v0UrlAttributes
 };
 function isAllowedFlowElement(model, name) {
   return model.flowElements.has(name) || name === model.mathRoot;
@@ -39,16 +101,17 @@ function isUnsafeAttribute(name, value) {
   }
   return false;
 }
-function sanitizeAttributes(model, attributes) {
+function sanitizeAttributes(model, elementName, attributes) {
   const safe = {};
   if (!attributes) {
     return safe;
   }
+  const elementAllowed = model.elementAttributes.get(elementName);
   for (const [name, value] of Object.entries(attributes)) {
     if (isUnsafeAttribute(name, value)) {
       continue;
     }
-    if (!model.globalAttributes.has(name)) {
+    if (!model.globalAttributes.has(name) && !elementAllowed?.has(name)) {
       continue;
     }
     if (typeof value === "string") {
@@ -57,6 +120,78 @@ function sanitizeAttributes(model, attributes) {
   }
   return safe;
 }
+function sanitizeMathAttributes(attributes) {
+  const safe = {};
+  if (!attributes) {
+    return safe;
+  }
+  for (const [name, value] of Object.entries(attributes)) {
+    if (!isUnsafeAttribute(name, value) && typeof value === "string") {
+      safe[name] = value;
+    }
+  }
+  return safe;
+}
+// src/graphic.ts
+function parseCoords(coords) {
+  return coords.split(",").map((entry) => Number(entry.trim())).filter((value) => !Number.isNaN(value));
+}
+function parsePoint(value) {
+  const [x, y, ...rest] = value.trim().split(/\s+/u).map(Number);
+  if (x === undefined || y === undefined || rest.length > 0 || Number.isNaN(x) || Number.isNaN(y)) {
+    return null;
+  }
+  return { x, y };
+}
+function formatPoint(point) {
+  return `${point.x} ${point.y}`;
+}
+function pointInPolygon(coords, point) {
+  let inside = false;
+  for (let i = 0, j = coords.length - 2;i < coords.length; j = i, i += 2) {
+    const xi = coords[i];
+    const yi = coords[i + 1];
+    const xj = coords[j];
+    const yj = coords[j + 1];
+    const intersects = yi > point.y !== yj > point.y && point.x < (xj - xi) * (point.y - yi) / (yj - yi) + xi;
+    if (intersects) {
+      inside = !inside;
+    }
+  }
+  return inside;
+}
+function pointInShape(shape, coords, point) {
+  switch (shape) {
+    case "default":
+      return true;
+    case "circle": {
+      const [cx, cy, r] = coords;
+      if (cx === undefined || cy === undefined || r === undefined) {
+        return false;
+      }
+      return (point.x - cx) ** 2 + (point.y - cy) ** 2 <= r ** 2;
+    }
+    case "rect": {
+      const [left, top, right, bottom] = coords;
+      if (left === undefined || top === undefined || right === undefined || bottom === undefined) {
+        return false;
+      }
+      return point.x >= left && point.x <= right && point.y >= top && point.y <= bottom;
+    }
+    case "ellipse": {
+      const [cx, cy, rx, ry] = coords;
+      if (cx === undefined || cy === undefined || rx === undefined || ry === undefined || rx === 0 || ry === 0) {
+        return false;
+      }
+      return (point.x - cx) ** 2 / rx ** 2 + (point.y - cy) ** 2 / ry ** 2 <= 1;
+    }
+    case "poly":
+      return coords.length >= 6 && pointInPolygon(coords, point);
+    default:
+      return false;
+  }
+}
+
 // src/response-processing.ts
 function foldString(value) {
   return value.normalize("NFD").replace(/\p{Diacritic}/gu, "").toLocaleLowerCase();
@@ -65,31 +200,62 @@ function asList(response) {
   if (response === null) {
     return [];
   }
-  return typeof response === "string" ? [response] : [...response];
+  return typeof response === "string" ? [response] : Array.isArray(response) ? [...response] : [];
 }
 function isStringBaseType(declaration) {
   return declaration.baseType === "string" || declaration.baseType === undefined;
 }
-function valuesEqual(a, b, fold) {
-  return fold ? foldString(a) === foldString(b) : a === b;
+function pairsEqual(a, b, directed) {
+  const [a1, a2] = a.trim().split(/\s+/u);
+  const [b1, b2] = b.trim().split(/\s+/u);
+  if (a1 === undefined || a2 === undefined || b1 === undefined || b2 === undefined) {
+    return false;
+  }
+  if (a1 === b1 && a2 === b2) {
+    return true;
+  }
+  return !directed && a1 === b2 && a2 === b1;
+}
+var numericBaseTypes = new Set(["float", "integer"]);
+function makeValueComparator(declaration, normalize) {
+  if (declaration.baseType === "pair") {
+    return (a, b) => pairsEqual(a, b, false);
+  }
+  if (declaration.baseType === "directedPair") {
+    return (a, b) => pairsEqual(a, b, true);
+  }
+  if (declaration.baseType !== undefined && numericBaseTypes.has(declaration.baseType)) {
+    return (a, b) => a.trim() !== "" && b.trim() !== "" && Number(a) === Number(b);
+  }
+  if (declaration.baseType === "point") {
+    return (a, b) => {
+      const pointA = parsePoint(a);
+      const pointB = parsePoint(b);
+      return pointA !== null && pointB !== null && pointA.x === pointB.x && pointA.y === pointB.y;
+    };
+  }
+  if (normalize && isStringBaseType(declaration)) {
+    return (a, b) => normalize(a, declaration) === normalize(b, declaration);
+  }
+  return (a, b) => a === b;
 }
-function matchCorrect(declaration, response) {
+function matchCorrect(declaration, response, normalize) {
   const correct = declaration.correctResponse;
   if (!correct) {
     return false;
   }
-  const fold = isStringBaseType(declaration);
+  const equals = makeValueComparator(declaration, normalize);
   const expected = correct.values.map((entry) => entry.value);
   const actual = asList(response);
   if (expected.length !== actual.length) {
     return false;
   }
   if (declaration.cardinality === "ordered") {
-    return expected.every((value, index) => valuesEqual(value, actual[index] ?? "", fold));
+    return expected.every((value, index) => equals(value, actual[index] ?? ""));
   }
   const remaining = [...actual];
   for (const value of expected) {
-    const matchIndex = remaining.findIndex((candidate) => valuesEqual(candidate, value, fold));
+    const matchIndex = remaining.findIndex((candidate) => equals(candidate, value));
     if (matchIndex === -1) {
       return false;
     }
@@ -107,22 +273,73 @@ function clamp(value, lower, upper) {
   }
   return result;
 }
-function mapResponse(declaration, response) {
+function mapResponse(declaration, response, normalize) {
   const mapping = declaration.mapping;
   if (!mapping) {
     return 0;
   }
+  const isPairType = declaration.baseType === "pair" || declaration.baseType === "directedPair";
+  const applyNormalize = normalize && isStringBaseType(declaration) ? normalize : undefined;
   const defaultValue = mapping.defaultValue ?? 0;
   let total = 0;
   for (const member of asList(response)) {
-    const entry = mapping.mapEntries.find((candidate) => valuesEqual(candidate.mapKey, member, !candidate.caseSensitive));
+    const entry = mapping.mapEntries.find((candidate) => {
+      if (isPairType) {
+        return pairsEqual(candidate.mapKey, member, declaration.baseType === "directedPair");
+      }
+      let key = candidate.mapKey;
+      let candidateMember = member;
+      if (candidate.caseSensitive === false) {
+        key = key.toLocaleLowerCase();
+        candidateMember = candidateMember.toLocaleLowerCase();
+      }
+      if (applyNormalize) {
+        key = applyNormalize(key, declaration);
+        candidateMember = applyNormalize(candidateMember, declaration);
+      }
+      return key === candidateMember;
+    });
     total += entry ? entry.mappedValue : defaultValue;
   }
   return clamp(total, mapping.lowerBound, mapping.upperBound);
 }
-function scoreResponse(declaration, response) {
+function mapResponsePoint(declaration, response) {
+  const areaMapping = declaration.areaMapping;
+  if (!areaMapping) {
+    return 0;
+  }
+  const defaultValue = areaMapping.defaultValue ?? 0;
+  const usedAreas = new Set;
+  let total = 0;
+  for (const member of asList(response)) {
+    const point = parsePoint(member);
+    if (!point) {
+      continue;
+    }
+    const areaIndex = areaMapping.areaMapEntries.findIndex((entry, index) => !usedAreas.has(index) && pointInShape(entry.shape, entry.coords, point));
+    if (areaIndex === -1) {
+      total += defaultValue;
+    } else {
+      usedAreas.add(areaIndex);
+      total += areaMapping.areaMapEntries[areaIndex].mappedValue;
+    }
+  }
+  return clamp(total, areaMapping.lowerBound, areaMapping.upperBound);
+}
+function scoreResponse(declaration, response, normalize) {
+  if (declaration.areaMapping) {
+    const score = mapResponsePoint(declaration, response);
+    const positiveSum = declaration.areaMapping.areaMapEntries.reduce((sum, entry) => sum + Math.max(entry.mappedValue, 0), 0);
+    const maxScore = declaration.areaMapping.upperBound ?? positiveSum;
+    return {
+      identifier: declaration.identifier,
+      score,
+      maxScore,
+      correct: maxScore > 0 && score >= maxScore
+    };
+  }
   if (declaration.mapping) {
-    const score = mapResponse(declaration, response);
+    const score = mapResponse(declaration, response, normalize);
     const positiveSum = declaration.mapping.mapEntries.reduce((sum, entry) => sum + Math.max(entry.mappedValue, 0), 0);
     const maxScore = declaration.mapping.upperBound ?? positiveSum;
     return {
@@ -132,7 +349,7 @@ function scoreResponse(declaration, response) {
       correct: maxScore > 0 && score >= maxScore
     };
   }
-  const correct = matchCorrect(declaration, response);
+  const correct = matchCorrect(declaration, response, normalize);
   return {
     identifier: declaration.identifier,
     score: correct ? 1 : 0,
@@ -140,215 +357,3409 @@ function scoreResponse(declaration, response) {
     correct
   };
 }
-// src/store.ts
-function createAttemptStore(declarations, initialResponses) {
-  const declarationsById = new Map(declarations.map((declaration) => [declaration.identifier, declaration]));
-  const listeners = new Set;
-  let snapshot = {
-    responses: { ...initialResponses },
-    submitted: false,
-    scores: []
-  };
-  function emit(next) {
-    snapshot = next;
-    for (const listener of listeners) {
-      listener();
-    }
+// src/normalized-item.ts
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function asRecords(value) {
+  return Array.isArray(value) ? value.filter(isRecord) : [];
+}
+var kindRenames = {
+  hotTextInteraction: "hottextInteraction",
+  hotText: "hottext"
+};
+function numberValue(value) {
+  if (typeof value === "number") {
+    return value;
   }
-  function computeScores(responses) {
-    return [...declarationsById.values()].map((declaration) => scoreResponse(declaration, responses[declaration.identifier] ?? null));
+  if (typeof value === "string" && value !== "") {
+    const parsed = Number(value);
+    return Number.isNaN(parsed) ? undefined : parsed;
   }
-  return {
-    getSnapshot: () => snapshot,
-    subscribe: (listener) => {
-      listeners.add(listener);
-      return () => {
-        listeners.delete(listener);
-      };
-    },
-    setResponse: (responseIdentifier, value) => {
-      if (snapshot.submitted) {
-        return;
-      }
-      emit({
-        ...snapshot,
-        responses: { ...snapshot.responses, [responseIdentifier]: value }
-      });
-    },
-    submit: () => {
-      const scores = computeScores(snapshot.responses);
-      emit({ ...snapshot, submitted: true, scores });
-      return scores;
-    },
-    reset: () => {
-      emit({ responses: { ...initialResponses }, submitted: false, scores: [] });
+  return;
+}
+function findImageSource(node) {
+  if (!isRecord(node)) {
+    return {};
+  }
+  const attributes = isRecord(node["attributes"]) ? node["attributes"] : {};
+  if (typeof attributes["data"] === "string" || typeof attributes["src"] === "string") {
+    return attributes;
+  }
+  for (const child of asRecords(node["children"])) {
+    const found = findImageSource(child);
+    if (typeof found["data"] === "string" || typeof found["src"] === "string") {
+      return found;
     }
-  };
+  }
+  return attributes;
 }
-// src/runtime.ts
-import {
-  createContext,
-  createElement,
-  useContext,
-  useMemo,
-  useSyncExternalStore
-} from "react";
-function defineInteraction(descriptor) {
-  return descriptor;
+function toStageObject(node) {
+  const attributes = findImageSource(node);
+  const data = attributes["data"] ?? attributes["src"];
+  const width = numberValue(attributes["width"]);
+  const height = numberValue(attributes["height"]);
+  return {
+    data: typeof data === "string" ? data : "",
+    ...width !== undefined ? { width } : {},
+    ...height !== undefined ? { height } : {},
+    ...typeof attributes["type"] === "string" ? { type: attributes["type"] } : {}
+  };
 }
-var RuntimeContext = createContext(null);
-function useRuntimeContext() {
-  const context = useContext(RuntimeContext);
-  if (!context) {
-    throw new Error("QTI runtime components must be rendered inside an <ItemRenderer>.");
+function flattenText(value) {
+  if (typeof value === "string") {
+    return value;
   }
-  return context;
-}
-function responseIncludes(value, optionIdentifier) {
-  if (value === null) {
-    return false;
+  if (Array.isArray(value)) {
+    return value.map(flattenText).join("");
+  }
+  if (!isRecord(value)) {
+    return "";
   }
-  return typeof value === "string" ? value === optionIdentifier : value.includes(optionIdentifier);
+  if (value["kind"] === "text") {
+    return typeof value["value"] === "string" ? value["value"] : "";
+  }
+  return flattenText(value["children"]) + flattenText(value["content"]) + flattenText(value["value"]);
 }
-function isCorrectOption(declaration, optionIdentifier) {
-  return Boolean(declaration?.correctResponse?.values.some((entry) => entry.value === optionIdentifier));
+function withNumericCoords(node) {
+  return typeof node["coords"] === "string" ? { ...node, coords: parseCoords(node["coords"]) } : node;
 }
-function createQtiRuntime(config) {
-  const model = config.contentModel ?? v0ContentModel;
-  const descriptorsByKind = new Map(config.interactions.map((descriptor) => [descriptor.kind, descriptor]));
-  function renderFlow(node, key) {
-    const isMath = node.name === model.mathRoot;
-    if (!isMath && !isAllowedFlowElement(model, node.name)) {
-      return null;
-    }
-    const attributes = sanitizeAttributes(model, node.attributes);
-    const children = node.children?.map((child, index) => renderNode(child, index));
-    return createElement(node.name, { key, ...attributes }, node.value ?? children);
+function reshapeContentNode(node) {
+  const kind = node["kind"];
+  if (typeof kind !== "string") {
+    return node;
   }
-  function renderNode(node, key) {
-    if (isInteractionKind(model, node.kind) && descriptorsByKind.has(node.kind) && config.skin[node.kind]) {
-      return createElement(InteractionHost, { key, node });
+  const renamed = kindRenames[kind];
+  if (renamed !== undefined) {
+    return { ...node, kind: renamed };
+  }
+  switch (kind) {
+    case "hotspotChoice":
+    case "associableHotspot":
+      return withNumericCoords(node);
+    case "hotspotInteraction":
+    case "graphicOrderInteraction":
+    case "graphicAssociateInteraction":
+    case "selectPointInteraction": {
+      const { image, ...rest } = node;
+      return { ...rest, object: toStageObject(image) };
     }
-    if (node.kind === "xml") {
-      return renderFlow(node, key);
+    case "drawingInteraction": {
+      const { content, ...rest } = node;
+      const media = asRecords(content).find((fragment) => fragment["kind"] === "xml" && typeof fragment["name"] === "string" && ["object", "picture", "img"].includes(fragment["name"]));
+      return { ...rest, object: toStageObject(media) };
     }
-    const value = node.value;
-    return typeof value === "string" ? value : null;
-  }
-  function InteractionHost({ node }) {
-    const { store, declarationsById } = useRuntimeContext();
-    const snapshot = useSyncExternalStore(store.subscribe, store.getSnapshot, store.getSnapshot);
-    const responseIdentifier = node.responseIdentifier;
-    const declaration = declarationsById.get(responseIdentifier);
-    const cardinality = declaration?.cardinality ?? "single";
-    const value = snapshot.responses[responseIdentifier] ?? null;
-    const disabled = snapshot.submitted;
-    const answered = value !== null && !(typeof value === "string" && value.trim() === "") && !(Array.isArray(value) && value.length === 0);
-    let status = answered ? "answered" : "unanswered";
-    if (disabled) {
-      const scored = snapshot.scores.find((score) => score.identifier === responseIdentifier);
-      status = scored?.correct ? "correct" : "incorrect";
+    case "graphicGapMatchInteraction": {
+      const { image, gapChoices, ...rest } = node;
+      const gapImgs = asRecords(gapChoices).map(({ media, content, ...choice }) => choice["kind"] === "gapImg" ? { ...choice, object: toStageObject(media) } : { ...choice, label: flattenText(content) });
+      return { ...rest, object: toStageObject(image), gapImgs };
     }
-    const setValue = (next) => {
-      store.setResponse(responseIdentifier, next);
-    };
-    const getOptionProps = (optionIdentifier) => {
-      const selected = responseIncludes(value, optionIdentifier);
-      let status2 = selected ? "selected" : "idle";
-      if (disabled) {
-        if (isCorrectOption(declaration, optionIdentifier)) {
-          status2 = "correct";
-        } else if (selected) {
-          status2 = "incorrect";
-        } else {
-          status2 = "idle";
-        }
+    case "gapMatchInteraction": {
+      const gapTexts = asRecords(node["gapChoices"]).filter((choice) => choice["kind"] === "gapText");
+      return { ...node, gapTexts };
+    }
+    case "mediaInteraction": {
+      const { media, ...rest } = node;
+      return { ...rest, content: media === undefined ? [] : [media] };
+    }
+    case "uploadInteraction": {
+      const acceptedTypes = node["acceptedTypes"];
+      return Array.isArray(acceptedTypes) ? { ...node, type: acceptedTypes.join(",") } : node;
+    }
+    case "positionObjectStage": {
+      const interactions = asRecords(node["positionObjectInteractions"]);
+      const [first] = interactions;
+      if (interactions.length === 1 && first) {
+        return {
+          kind: "positionObjectStage",
+          responseIdentifier: first["responseIdentifier"],
+          stageObject: toStageObject(node["image"]),
+          object: toStageObject(first["image"]),
+          ...first["maxChoices"] !== undefined ? { maxChoices: first["maxChoices"] } : {},
+          ...first["minChoices"] !== undefined ? { minChoices: first["minChoices"] } : {}
+        };
       }
-      return {
-        role: cardinality === "single" ? "radio" : "checkbox",
-        tabIndex: 0,
-        "aria-checked": selected,
-        "aria-disabled": disabled,
-        "data-status": status2,
-        onClick: () => {
-          if (disabled) {
-            return;
-          }
-          if (cardinality === "single") {
-            setValue(optionIdentifier);
-            return;
-          }
-          const current = value === null ? [] : typeof value === "string" ? [value] : [...value];
-          const next = selected ? current.filter((entry) => entry !== optionIdentifier) : [...current, optionIdentifier];
-          setValue(next);
-        }
-      };
-    };
-    const renderContent = (nodes) => nodes ? nodes.map((child, index) => renderNode(child, index)) : null;
-    const Skin = config.skin[node.kind];
-    if (!Skin) {
-      return null;
+      const responseIdentifier = first?.["responseIdentifier"];
+      return { ...node, ...typeof responseIdentifier === "string" ? { responseIdentifier } : {} };
     }
-    return createElement(Skin, {
-      node,
-      responseIdentifier,
-      value,
-      setValue,
-      disabled,
-      showFeedback: disabled,
-      status,
-      getOptionProps,
-      renderContent
-    });
+    default:
+      return node;
   }
-  function ItemRenderer({ item, children }) {
-    const store = useMemo(() => {
-      const initial = {};
-      for (const node of item.itemBody.content ?? []) {}
-      return createAttemptStore(item.responseDeclarations, initial);
-    }, [item]);
-    const declarationsById = useMemo(() => new Map(item.responseDeclarations.map((declaration) => [declaration.identifier, declaration])), [item]);
-    const body = (item.itemBody.content ?? []).map((node, index) => renderNode(node, index));
-    return createElement(RuntimeContext.Provider, { value: { store, declarationsById } }, body, children);
+}
+function convertContentEntry(entry) {
+  if (typeof entry === "string") {
+    return { kind: "text", value: entry };
   }
-  function useAttempt() {
-    const { store } = useRuntimeContext();
-    const snapshot = useSyncExternalStore(store.subscribe, store.getSnapshot, store.getSnapshot);
+  return convertContentValue(entry);
+}
+function convertContentValue(value) {
+  if (Array.isArray(value)) {
+    return value.map(convertContentValue);
+  }
+  if (!isRecord(value)) {
+    return value;
+  }
+  const converted = Object.fromEntries(Object.entries(value).map(([key, entry]) => {
+    if ((key === "children" || key === "content") && Array.isArray(entry)) {
+      return [key, entry.map(convertContentEntry)];
+    }
+    return [key, convertContentValue(entry)];
+  }));
+  return reshapeContentNode(converted);
+}
+function convertExpression(expression) {
+  const record = isRecord(expression) ? expression : {};
+  const { children, ...rest } = record;
+  return {
+    ...rest,
+    ...Array.isArray(children) ? { expressions: children.map(convertExpression) } : {}
+  };
+}
+function convertBranch(branch, convertRule) {
+  const record = isRecord(branch) ? branch : {};
+  return {
+    expression: convertExpression(record["expression"]),
+    rules: (Array.isArray(record["actions"]) ? record["actions"] : []).map(convertRule)
+  };
+}
+function convertRpRule(rule) {
+  const record = isRecord(rule) ? rule : {};
+  const kind = typeof record["kind"] === "string" ? record["kind"] : "";
+  if (kind === "responseCondition") {
+    const elseIfs = Array.isArray(record["responseElseIf"]) ? record["responseElseIf"].map((branch) => convertBranch(branch, convertRpRule)) : [];
     return {
-      ...snapshot,
-      submit: store.submit,
-      reset: store.reset
+      kind,
+      responseIf: convertBranch(record["responseIf"], convertRpRule),
+      ...elseIfs.length ? { responseElseIfs: elseIfs } : {},
+      ...isRecord(record["responseElse"]) ? {
+        responseElse: {
+          rules: (Array.isArray(record["responseElse"]["actions"]) ? record["responseElse"]["actions"] : []).map(convertRpRule)
+        }
+      } : {}
     };
   }
-  return { ItemRenderer, useAttempt };
+  return {
+    kind,
+    ...typeof record["identifier"] === "string" ? { identifier: record["identifier"] } : {},
+    ...record["expression"] !== undefined ? { expression: convertExpression(record["expression"]) } : {}
+  };
 }
-// src/interactions/choice.ts
-import { z } from "zod";
-var choiceInteractionNodeSchema = z.object({
-  kind: z.literal("choiceInteraction"),
-  responseIdentifier: z.string().min(1),
-  simpleChoices: z.array(z.object({ identifier: z.string().min(1) })).min(1),
-  maxChoices: z.number().int().optional()
-});
-var choiceInteraction = defineInteraction({
-  kind: "choiceInteraction",
-  schema: choiceInteractionNodeSchema,
-  scoring: "qti-standard",
-  initialResponse() {
+function convertTemplateRule(rule) {
+  const record = isRecord(rule) ? rule : {};
+  const kind = typeof record["kind"] === "string" ? record["kind"] : "";
+  if (kind === "templateCondition") {
+    const elseIfs = Array.isArray(record["templateElseIf"]) ? record["templateElseIf"].map((branch) => convertBranch(branch, convertTemplateRule)) : [];
+    return {
+      kind,
+      templateIf: convertBranch(record["templateIf"], convertTemplateRule),
+      ...elseIfs.length ? { templateElseIfs: elseIfs } : {},
+      ...isRecord(record["templateElse"]) ? {
+        templateElse: {
+          rules: (Array.isArray(record["templateElse"]["actions"]) ? record["templateElse"]["actions"] : []).map(convertTemplateRule)
+        }
+      } : {}
+    };
+  }
+  return {
+    kind,
+    ...typeof record["identifier"] === "string" ? { identifier: record["identifier"] } : {},
+    ...record["expression"] !== undefined ? { expression: convertExpression(record["expression"]) } : {}
+  };
+}
+function convertResponseProcessing(value) {
+  return {
+    ...typeof value["template"] === "string" ? { template: value["template"] } : {},
+    ...Array.isArray(value["rules"]) ? { rules: value["rules"].map(convertRpRule) } : {}
+  };
+}
+function convertResponseDeclaration(declaration) {
+  const areaMapping = declaration["areaMapping"];
+  if (!isRecord(areaMapping)) {
+    return declaration;
+  }
+  const areaMapEntries = asRecords(areaMapping["areaMapEntries"]).map((entry) => withNumericCoords(entry));
+  return { ...declaration, areaMapping: { ...areaMapping, areaMapEntries } };
+}
+function assessmentItemViewFromNormalized(document) {
+  if (!isRecord(document) || !isRecord(document["assessmentItem"])) {
     return null;
   }
-});
-
-// src/interactions/inline-choice.ts
-import { z as z2 } from "zod";
-var inlineChoiceInteractionNodeSchema = z2.object({
-  kind: z2.literal("inlineChoiceInteraction"),
-  responseIdentifier: z2.string().min(1),
-  inlineChoices: z2.array(z2.object({ identifier: z2.string().min(1) })).min(1)
-});
-var inlineChoiceInteraction = defineInteraction({
-  kind: "inlineChoiceInteraction",
-  schema: inlineChoiceInteractionNodeSchema,
+  const item = document["assessmentItem"];
+  const itemBody = isRecord(item["itemBody"]) ? item["itemBody"] : {};
+  const content = Array.isArray(itemBody["content"]) ? itemBody["content"].map(convertContentEntry) : [];
+  const templateRules = isRecord(item["templateProcessing"]) ? item["templateProcessing"]["rules"] : undefined;
+  return {
+    responseDeclarations: asRecords(item["responseDeclarations"]).map(convertResponseDeclaration),
+    outcomeDeclarations: item["outcomeDeclarations"] ?? [],
+    ...isRecord(item["responseProcessing"]) ? { responseProcessing: convertResponseProcessing(item["responseProcessing"]) } : {},
+    ...Array.isArray(item["templateDeclarations"]) ? { templateDeclarations: item["templateDeclarations"] } : {},
+    ...Array.isArray(templateRules) ? {
+      templateProcessing: {
+        rules: templateRules.map(convertTemplateRule)
+      }
+    } : {},
+    ...typeof item["adaptive"] === "boolean" ? { adaptive: item["adaptive"] } : {},
+    ...Array.isArray(item["modalFeedbacks"]) ? { modalFeedbacks: item["modalFeedbacks"].map(convertContentValue) } : {},
+    itemBody: { content }
+  };
+}
+function convertPreConditions(value) {
+  return asRecords(value).map((wrapper) => convertExpression(wrapper["expression"]));
+}
+function convertBranchRules(value) {
+  return asRecords(value).map((rule) => ({
+    target: typeof rule["target"] === "string" ? rule["target"] : "",
+    expression: convertExpression(rule["expression"])
+  }));
+}
+function convertOutcomeRule(rule) {
+  const record = isRecord(rule) ? rule : {};
+  const kind = typeof record["kind"] === "string" ? record["kind"] : "";
+  if (kind === "outcomeCondition") {
+    const elseIfs = Array.isArray(record["outcomeElseIf"]) ? record["outcomeElseIf"].map((branch) => convertBranch(branch, convertOutcomeRule)) : [];
+    return {
+      kind,
+      outcomeIf: convertBranch(record["outcomeIf"], convertOutcomeRule),
+      ...elseIfs.length ? { outcomeElseIfs: elseIfs } : {},
+      ...isRecord(record["outcomeElse"]) ? {
+        outcomeElse: {
+          rules: (Array.isArray(record["outcomeElse"]["actions"]) ? record["outcomeElse"]["actions"] : []).map(convertOutcomeRule)
+        }
+      } : {}
+    };
+  }
+  return {
+    kind,
+    ...typeof record["identifier"] === "string" ? { identifier: record["identifier"] } : {},
+    ...record["expression"] !== undefined ? { expression: convertExpression(record["expression"]) } : {}
+  };
+}
+function sessionControlAndTimeLimits(record) {
+  return {
+    ...isRecord(record["itemSessionControl"]) ? { itemSessionControl: record["itemSessionControl"] } : {},
+    ...isRecord(record["timeLimits"]) ? { timeLimits: record["timeLimits"] } : {}
+  };
+}
+function convertItemRef(ref) {
+  return {
+    kind: "assessmentItemRef",
+    identifier: typeof ref["identifier"] === "string" ? ref["identifier"] : "",
+    ...typeof ref["href"] === "string" ? { href: ref["href"] } : {},
+    ...Array.isArray(ref["category"]) ? { categories: ref["category"] } : {},
+    ...typeof ref["fixed"] === "boolean" ? { fixed: ref["fixed"] } : {},
+    ...typeof ref["required"] === "boolean" ? { required: ref["required"] } : {},
+    ...ref["preConditions"] !== undefined ? { preConditions: convertPreConditions(ref["preConditions"]) } : {},
+    ...ref["branchRules"] !== undefined ? { branchRules: convertBranchRules(ref["branchRules"]) } : {},
+    ...Array.isArray(ref["weights"]) ? { weights: ref["weights"] } : {},
+    ...sessionControlAndTimeLimits(ref)
+  };
+}
+function convertSection(section) {
+  const children = asRecords(section["children"]).map((child) => child["visible"] !== undefined || child["children"] !== undefined ? convertSection(child) : convertItemRef(child));
+  return {
+    kind: "assessmentSection",
+    identifier: typeof section["identifier"] === "string" ? section["identifier"] : "",
+    ...typeof section["title"] === "string" ? { title: section["title"] } : {},
+    ...typeof section["visible"] === "boolean" ? { visible: section["visible"] } : {},
+    ...typeof section["fixed"] === "boolean" ? { fixed: section["fixed"] } : {},
+    ...typeof section["required"] === "boolean" ? { required: section["required"] } : {},
+    ...isRecord(section["selection"]) ? { selection: section["selection"] } : {},
+    ...isRecord(section["ordering"]) ? { ordering: section["ordering"] } : {},
+    ...section["preConditions"] !== undefined ? { preConditions: convertPreConditions(section["preConditions"]) } : {},
+    ...section["branchRules"] !== undefined ? { branchRules: convertBranchRules(section["branchRules"]) } : {},
+    ...sessionControlAndTimeLimits(section),
+    children
+  };
+}
+function convertTestFeedback(feedback) {
+  const converted = convertContentValue(feedback);
+  return {
+    outcomeIdentifier: typeof converted["outcomeIdentifier"] === "string" ? converted["outcomeIdentifier"] : "",
+    identifier: typeof converted["identifier"] === "string" ? converted["identifier"] : "",
+    ...converted["access"] === "atEnd" || converted["access"] === "during" ? { access: converted["access"] } : {},
+    ...converted["showHide"] === "show" || converted["showHide"] === "hide" ? { showHide: converted["showHide"] } : {},
+    ...Array.isArray(converted["content"]) ? { content: converted["content"] } : {}
+  };
+}
+function assessmentTestViewFromNormalized(document) {
+  if (!isRecord(document) || !isRecord(document["assessmentTest"])) {
+    return null;
+  }
+  const testDocument = document["assessmentTest"];
+  const outcomeRules = isRecord(testDocument["outcomeProcessing"]) ? testDocument["outcomeProcessing"]["rules"] : undefined;
+  const testParts = asRecords(testDocument["testParts"]).map((part) => ({
+    identifier: typeof part["identifier"] === "string" ? part["identifier"] : "",
+    navigationMode: part["navigationMode"] === "nonlinear" ? "nonlinear" : "linear",
+    submissionMode: part["submissionMode"] === "simultaneous" ? "simultaneous" : "individual",
+    ...part["preConditions"] !== undefined ? { preConditions: convertPreConditions(part["preConditions"]) } : {},
+    ...part["branchRules"] !== undefined ? { branchRules: convertBranchRules(part["branchRules"]) } : {},
+    ...sessionControlAndTimeLimits(part),
+    assessmentSections: asRecords(part["children"]).map(convertSection)
+  }));
+  return {
+    identifier: typeof testDocument["identifier"] === "string" ? testDocument["identifier"] : "",
+    ...typeof testDocument["title"] === "string" ? { title: testDocument["title"] } : {},
+    outcomeDeclarations: testDocument["outcomeDeclarations"] ?? [],
+    ...isRecord(testDocument["timeLimits"]) ? { timeLimits: testDocument["timeLimits"] } : {},
+    testParts,
+    ...Array.isArray(outcomeRules) ? { outcomeProcessing: { rules: outcomeRules.map(convertOutcomeRule) } } : {},
+    ...Array.isArray(testDocument["testFeedbacks"]) ? { testFeedbacks: asRecords(testDocument["testFeedbacks"]).map(convertTestFeedback) } : {}
+  };
+}
+// src/types.ts
+function isResponseRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// src/rp/values.ts
+var numericBaseTypes2 = new Set(["float", "integer", "duration"]);
+function isNumericBaseType(baseType) {
+  return baseType !== undefined && numericBaseTypes2.has(baseType);
+}
+function coerceScalar(value, baseType) {
+  if (isNumericBaseType(baseType) && typeof value === "string" && value.trim() !== "") {
+    const parsed = Number(value);
+    if (!Number.isNaN(parsed)) {
+      return parsed;
+    }
+  }
+  if (baseType === "boolean" && typeof value === "string") {
+    return value === "true";
+  }
+  return value;
+}
+function fieldBaseType(value) {
+  return typeof value === "boolean" ? "boolean" : typeof value === "number" ? "float" : "string";
+}
+function fromResponse(declaration, response) {
+  if (response === null) {
+    return null;
+  }
+  if (isResponseRecord(response)) {
+    const fields = Object.entries(response).flatMap(([name, member]) => member === null ? [] : [{ name, baseType: fieldBaseType(member), value: member }]);
+    return fields.length === 0 ? null : { cardinality: "record", fields, values: fields.map((field) => field.value) };
+  }
+  const raw = typeof response === "string" ? [response] : [...response];
+  if (raw.length === 0) {
+    return null;
+  }
+  return rpValue(declaration.cardinality, raw.map((value) => coerceScalar(value, declaration.baseType)), declaration.baseType);
+}
+function singleNumber(value) {
+  if (value === null || value.values.length !== 1) {
+    return null;
+  }
+  const member = value.values[0];
+  return typeof member === "number" ? member : null;
+}
+function singleBoolean(value) {
+  if (value === null || value.values.length !== 1) {
+    return null;
+  }
+  const member = value.values[0];
+  return typeof member === "boolean" ? member : null;
+}
+function rpValue(cardinality, values, baseType) {
+  return {
+    cardinality,
+    values,
+    ...baseType !== undefined ? { baseType } : {}
+  };
+}
+function booleanValue(value) {
+  return { cardinality: "single", baseType: "boolean", values: [value] };
+}
+function floatValue(value) {
+  return { cardinality: "single", baseType: "float", values: [value] };
+}
+function pairsEqual2(a, b, directed) {
+  const [a1, a2] = a.trim().split(/\s+/u);
+  const [b1, b2] = b.trim().split(/\s+/u);
+  if (a1 === undefined || a2 === undefined || b1 === undefined || b2 === undefined) {
+    return false;
+  }
+  if (a1 === b1 && a2 === b2) {
+    return true;
+  }
+  return !directed && a1 === b2 && a2 === b1;
+}
+function scalarsEqual(a, b, baseType, normalize) {
+  if (baseType === "pair" || baseType === "directedPair") {
+    return typeof a === "string" && typeof b === "string" && pairsEqual2(a, b, baseType === "directedPair");
+  }
+  if (baseType === "point") {
+    if (typeof a !== "string" || typeof b !== "string") {
+      return false;
+    }
+    const pointA = parsePoint(a);
+    const pointB = parsePoint(b);
+    return pointA !== null && pointB !== null && pointA.x === pointB.x && pointA.y === pointB.y;
+  }
+  if (typeof a === "number" || typeof b === "number") {
+    return Number(a) === Number(b);
+  }
+  if (normalize && baseType === "string" && typeof a === "string" && typeof b === "string") {
+    return normalize(a) === normalize(b);
+  }
+  return a === b;
+}
+function valuesMatch(a, b, normalize) {
+  const baseType = a.baseType ?? b.baseType;
+  if (a.values.length !== b.values.length) {
+    return false;
+  }
+  if (a.cardinality === "ordered" || b.cardinality === "ordered") {
+    return a.values.every((value, index) => scalarsEqual(value, b.values[index], baseType, normalize));
+  }
+  const remaining = [...b.values];
+  for (const value of a.values) {
+    const matchIndex = remaining.findIndex((candidate) => scalarsEqual(candidate, value, baseType, normalize));
+    if (matchIndex === -1) {
+      return false;
+    }
+    remaining.splice(matchIndex, 1);
+  }
+  return true;
+}
+function fromFlatValue(value, cardinality, baseType) {
+  if (value === null) {
+    return null;
+  }
+  const values = Array.isArray(value) ? [...value] : [value];
+  if (values.length === 0) {
+    return null;
+  }
+  return rpValue(cardinality, values.map((member) => coerceScalar(member, baseType)), baseType);
+}
+function toOutcomeValue(value) {
+  if (value === null || value.values.length === 0) {
+    return null;
+  }
+  if (value.cardinality === "single") {
+    return value.values[0] ?? null;
+  }
+  return value.values;
+}
+
+// src/rp/evaluate.ts
+var deterministicExpressionKinds = new Set([
+  "and",
+  "baseValue",
+  "correct",
+  "delete",
+  "divide",
+  "equal",
+  "equalRounded",
+  "fieldValue",
+  "gcd",
+  "gt",
+  "gte",
+  "index",
+  "inside",
+  "lcm",
+  "integerDivide",
+  "integerModulus",
+  "integerToFloat",
+  "isNull",
+  "lt",
+  "lte",
+  "mapResponse",
+  "mapResponsePoint",
+  "match",
+  "mathConstant",
+  "mathOperator",
+  "max",
+  "member",
+  "min",
+  "multiple",
+  "not",
+  "or",
+  "ordered",
+  "product",
+  "repeat",
+  "round",
+  "roundTo",
+  "statsOperator",
+  "stringMatch",
+  "substring",
+  "subtract",
+  "sum",
+  "truncate",
+  "variable"
+]);
+var randomExpressionKinds = new Set(["random", "randomFloat", "randomInteger"]);
+
+class RpUnsupportedError extends Error {
+  kindName;
+  constructor(kindName) {
+    super(`Unsupported response-processing construct: ${kindName}`);
+    this.kindName = kindName;
+  }
+}
+var mathConstants = { pi: Math.PI, e: Math.E };
+function applyMathOperator(name, x, y) {
+  switch (name) {
+    case "sin":
+      return Math.sin(x);
+    case "cos":
+      return Math.cos(x);
+    case "tan":
+      return Math.tan(x);
+    case "sec":
+      return 1 / Math.cos(x);
+    case "csc":
+      return 1 / Math.sin(x);
+    case "cot":
+      return Math.cos(x) / Math.sin(x);
+    case "asin":
+      return Math.asin(x);
+    case "acos":
+      return Math.acos(x);
+    case "atan":
+      return Math.atan(x);
+    case "atan2":
+      return Math.atan2(x, y);
+    case "asec":
+      return Math.acos(1 / x);
+    case "acsc":
+      return Math.asin(1 / x);
+    case "acot":
+      return Math.atan(1 / x);
+    case "sinh":
+      return Math.sinh(x);
+    case "cosh":
+      return Math.cosh(x);
+    case "tanh":
+      return Math.tanh(x);
+    case "sech":
+      return 1 / Math.cosh(x);
+    case "csch":
+      return 1 / Math.sinh(x);
+    case "coth":
+      return Math.cosh(x) / Math.sinh(x);
+    case "log":
+      return Math.log10(x);
+    case "ln":
+      return Math.log(x);
+    case "exp":
+      return Math.exp(x);
+    case "abs":
+      return Math.abs(x);
+    case "signum":
+      return Math.sign(x);
+    case "floor":
+      return Math.floor(x);
+    case "ceil":
+      return Math.ceil(x);
+    case "toDegrees":
+      return x * 180 / Math.PI;
+    case "toRadians":
+      return x * Math.PI / 180;
+    default:
+      return;
+  }
+}
+function roundToFigures(value, mode, figures) {
+  if (mode === "decimalPlaces") {
+    const scale2 = 10 ** figures;
+    return Math.round(value * scale2) / scale2;
+  }
+  if (figures < 1) {
+    return null;
+  }
+  if (value === 0) {
+    return 0;
+  }
+  const magnitude = Math.floor(Math.log10(Math.abs(value)));
+  const scale = 10 ** (figures - 1 - magnitude);
+  return Math.round(value * scale) / scale;
+}
+function evaluateExpression(expression, env) {
+  function evaluate(child) {
+    return evaluateExpression(child, env);
+  }
+  switch (expression.kind) {
+    case "baseValue": {
+      const baseType = expression.baseType;
+      const value = expression.value;
+      return value === undefined ? null : rpValue("single", [coerceScalar(value, baseType)], baseType);
+    }
+    case "variable":
+      return env.lookupVariable(expression.identifier ?? "");
+    case "correct": {
+      const declaration = env.responseDeclaration(expression.identifier ?? "");
+      if (!declaration?.correctResponse) {
+        return null;
+      }
+      return rpValue(declaration.cardinality, declaration.correctResponse.values.map((entry) => coerceScalar(entry.value, declaration.baseType)), declaration.baseType);
+    }
+    case "mapResponse": {
+      const identifier = expression.identifier ?? "";
+      const declaration = env.responseDeclaration(identifier);
+      if (!declaration) {
+        return null;
+      }
+      return floatValue(mapResponse(declaration, env.responseValue(identifier), env.normalization));
+    }
+    case "mapResponsePoint": {
+      const identifier = expression.identifier ?? "";
+      const declaration = env.responseDeclaration(identifier);
+      if (!declaration) {
+        return null;
+      }
+      return floatValue(mapResponsePoint(declaration, env.responseValue(identifier)));
+    }
+    case "match": {
+      const [a, b] = (expression.expressions ?? []).map(evaluate);
+      if (a === undefined || b === undefined || a === null || b === null) {
+        return null;
+      }
+      return booleanValue(valuesMatch(a, b, env.normalization));
+    }
+    case "isNull": {
+      const operand = expression.expressions?.[0];
+      return booleanValue(operand === undefined || evaluate(operand) === null);
+    }
+    case "not": {
+      const operand = expression.expressions?.[0];
+      const value = operand === undefined ? null : singleBoolean(evaluate(operand));
+      return value === null ? null : booleanValue(!value);
+    }
+    case "fieldValue": {
+      const operand = expression.expressions?.[0];
+      const value = operand === undefined ? null : evaluate(operand);
+      const field = value?.fields?.find((entry) => entry.name === expression.fieldIdentifier);
+      return field === undefined ? null : rpValue("single", [field.value], field.baseType);
+    }
+    case "and":
+    case "or": {
+      const members = (expression.expressions ?? []).map((child) => singleBoolean(evaluate(child)));
+      return booleanValue(expression.kind === "and" ? members.every((member) => member === true) : members.some((member) => member === true));
+    }
+    case "sum":
+    case "product": {
+      let result = expression.kind === "sum" ? 0 : 1;
+      for (const child of expression.expressions ?? []) {
+        const value = evaluate(child);
+        if (value === null) {
+          return null;
+        }
+        for (const member of value.values) {
+          if (typeof member !== "number") {
+            return null;
+          }
+          result = expression.kind === "sum" ? result + member : result * member;
+        }
+      }
+      return floatValue(result);
+    }
+    case "subtract":
+    case "divide": {
+      const [a, b] = (expression.expressions ?? []).map((child) => singleNumber(evaluate(child)));
+      if (a === undefined || b === undefined || a === null || b === null) {
+        return null;
+      }
+      if (expression.kind === "divide") {
+        return b === 0 ? null : floatValue(a / b);
+      }
+      return floatValue(a - b);
+    }
+    case "gt":
+    case "gte":
+    case "lt":
+    case "lte": {
+      const [a, b] = (expression.expressions ?? []).map((child) => singleNumber(evaluate(child)));
+      if (a === undefined || b === undefined || a === null || b === null) {
+        return null;
+      }
+      const comparisons = { gt: a > b, gte: a >= b, lt: a < b, lte: a <= b };
+      return booleanValue(comparisons[expression.kind]);
+    }
+    case "equal": {
+      const [a, b] = (expression.expressions ?? []).map((child) => singleNumber(evaluate(child)));
+      if (a === undefined || b === undefined || a === null || b === null) {
+        return null;
+      }
+      const mode = expression.toleranceMode ?? "exact";
+      if (mode === "exact") {
+        return booleanValue(a === b);
+      }
+      const t0 = expression.tolerance?.[0];
+      const t1 = expression.tolerance?.[1] ?? t0;
+      if (typeof t0 !== "number" || typeof t1 !== "number") {
+        throw new RpUnsupportedError("equal");
+      }
+      const lower = mode === "absolute" ? a - t0 : a * (1 - t0 / 100);
+      const upper = mode === "absolute" ? a + t1 : a * (1 + t1 / 100);
+      const aboveLower = expression.includeLowerBound ?? true ? b >= lower : b > lower;
+      const belowUpper = expression.includeUpperBound ?? true ? b <= upper : b < upper;
+      return booleanValue(aboveLower && belowUpper);
+    }
+    case "round":
+    case "truncate": {
+      const operand = expression.expressions?.[0];
+      const value = operand === undefined ? null : singleNumber(evaluate(operand));
+      if (value === null) {
+        return null;
+      }
+      const rounded = expression.kind === "round" ? Math.round(value) : Math.trunc(value);
+      return { cardinality: "single", baseType: "integer", values: [rounded] };
+    }
+    case "index": {
+      if (typeof expression.n !== "number") {
+        throw new RpUnsupportedError("index");
+      }
+      const operand = expression.expressions?.[0];
+      const container = operand === undefined ? null : evaluate(operand);
+      if (container === null) {
+        return null;
+      }
+      const member = container.values[expression.n - 1];
+      if (member === undefined) {
+        return null;
+      }
+      return rpValue("single", [member], container.baseType);
+    }
+    case "mathConstant": {
+      const constant = expression.name === undefined ? undefined : mathConstants[expression.name];
+      if (constant === undefined) {
+        throw new RpUnsupportedError("mathConstant");
+      }
+      return floatValue(constant);
+    }
+    case "mathOperator": {
+      const [x, y] = (expression.expressions ?? []).map((child) => singleNumber(evaluate(child)));
+      if (x === undefined || x === null || expression.name === "atan2" && (y === undefined || y === null)) {
+        return null;
+      }
+      const result = expression.name === undefined ? undefined : applyMathOperator(expression.name, x, y ?? NaN);
+      if (result === undefined) {
+        throw new RpUnsupportedError("mathOperator");
+      }
+      return Number.isFinite(result) ? floatValue(result) : null;
+    }
+    case "integerDivide":
+    case "integerModulus": {
+      const [a, b] = (expression.expressions ?? []).map((child) => singleNumber(evaluate(child)));
+      if (a === undefined || b === undefined || a === null || b === null || b === 0) {
+        return null;
+      }
+      const result = expression.kind === "integerDivide" ? Math.trunc(a / b) : a % b;
+      return { cardinality: "single", baseType: "integer", values: [result] };
+    }
+    case "integerToFloat": {
+      const operand = expression.expressions?.[0];
+      const value = operand === undefined ? null : singleNumber(evaluate(operand));
+      return value === null ? null : floatValue(value);
+    }
+    case "min":
+    case "max": {
+      const members = [];
+      for (const child of expression.expressions ?? []) {
+        const value = evaluate(child);
+        if (value === null) {
+          return null;
+        }
+        for (const member of value.values) {
+          if (typeof member !== "number") {
+            return null;
+          }
+          members.push(member);
+        }
+      }
+      if (members.length === 0) {
+        return null;
+      }
+      return floatValue(expression.kind === "min" ? Math.min(...members) : Math.max(...members));
+    }
+    case "gcd":
+    case "lcm": {
+      const members = [];
+      for (const child of expression.expressions ?? []) {
+        const value = evaluate(child);
+        if (value === null) {
+          return null;
+        }
+        for (const member of value.values) {
+          if (typeof member !== "number" || !Number.isInteger(member)) {
+            return null;
+          }
+          members.push(Math.abs(member));
+        }
+      }
+      if (members.length === 0) {
+        return null;
+      }
+      const gcdOf = (a, b) => b === 0 ? a : gcdOf(b, a % b);
+      const result = expression.kind === "gcd" ? members.reduce(gcdOf) : members.reduce((a, b) => a === 0 || b === 0 ? 0 : a / gcdOf(a, b) * b);
+      return { cardinality: "single", baseType: "integer", values: [result] };
+    }
+    case "roundTo": {
+      if (typeof expression.figures !== "number") {
+        throw new RpUnsupportedError("roundTo");
+      }
+      const operand = expression.expressions?.[0];
+      const value = operand === undefined ? null : singleNumber(evaluate(operand));
+      if (value === null) {
+        return null;
+      }
+      const rounded = roundToFigures(value, expression.roundingMode ?? "significantFigures", expression.figures);
+      return rounded === null ? null : floatValue(rounded);
+    }
+    case "equalRounded": {
+      if (typeof expression.figures !== "number") {
+        throw new RpUnsupportedError("equalRounded");
+      }
+      const [a, b] = (expression.expressions ?? []).map((child) => singleNumber(evaluate(child)));
+      if (a === undefined || b === undefined || a === null || b === null) {
+        return null;
+      }
+      const mode = expression.roundingMode ?? "significantFigures";
+      const roundedA = roundToFigures(a, mode, expression.figures);
+      const roundedB = roundToFigures(b, mode, expression.figures);
+      return roundedA === null || roundedB === null ? null : booleanValue(roundedA === roundedB);
+    }
+    case "statsOperator": {
+      const operand = expression.expressions?.[0];
+      const container = operand === undefined ? null : evaluate(operand);
+      if (container === null) {
+        return null;
+      }
+      const members = [];
+      for (const member of container.values) {
+        if (typeof member !== "number") {
+          return null;
+        }
+        members.push(member);
+      }
+      const count = members.length;
+      if (count === 0) {
+        return null;
+      }
+      const mean = members.reduce((sum, member) => sum + member, 0) / count;
+      const sumSquares = members.reduce((sum, member) => sum + (member - mean) ** 2, 0);
+      switch (expression.name) {
+        case "mean":
+          return floatValue(mean);
+        case "popVariance":
+          return floatValue(sumSquares / count);
+        case "popSD":
+          return floatValue(Math.sqrt(sumSquares / count));
+        case "sampleVariance":
+          return count < 2 ? null : floatValue(sumSquares / (count - 1));
+        case "sampleSD":
+          return count < 2 ? null : floatValue(Math.sqrt(sumSquares / (count - 1)));
+        default:
+          throw new RpUnsupportedError("statsOperator");
+      }
+    }
+    case "delete": {
+      const [valueExpression, containerExpression] = expression.expressions ?? [];
+      if (valueExpression === undefined || containerExpression === undefined) {
+        return null;
+      }
+      const value = evaluate(valueExpression);
+      const container = evaluate(containerExpression);
+      if (value === null || container === null) {
+        return null;
+      }
+      const scalar = value.values[0];
+      if (scalar === undefined) {
+        return null;
+      }
+      const baseType = container.baseType ?? value.baseType;
+      const remaining = container.values.filter((member) => !scalarsEqual(member, scalar, baseType, env.normalization));
+      return remaining.length === 0 ? null : rpValue(container.cardinality, remaining, container.baseType);
+    }
+    case "repeat": {
+      if (typeof expression.numberRepeats !== "number") {
+        throw new RpUnsupportedError("repeat");
+      }
+      if (expression.numberRepeats < 1) {
+        return null;
+      }
+      const members = [];
+      let baseType;
+      for (let pass = 0;pass < expression.numberRepeats; pass += 1) {
+        for (const child of expression.expressions ?? []) {
+          const value = evaluate(child);
+          if (value === null) {
+            continue;
+          }
+          baseType ??= value.baseType;
+          members.push(...value.values);
+        }
+      }
+      return members.length === 0 ? null : rpValue("ordered", members, baseType);
+    }
+    case "stringMatch":
+    case "substring": {
+      const [a, b] = (expression.expressions ?? []).map((child) => {
+        const value = evaluate(child);
+        const member = value?.values[0];
+        return typeof member === "string" ? member : null;
+      });
+      if (a === undefined || b === undefined || a === null || b === null) {
+        return null;
+      }
+      const normalize = (input) => {
+        const normalized = env.normalization?.(input) ?? input;
+        return expression.caseSensitive === false ? normalized.toLowerCase() : normalized;
+      };
+      const [left, right] = [normalize(a), normalize(b)];
+      const contains = expression.kind === "substring" || expression.substring === true;
+      return booleanValue(contains ? right.includes(left) : left === right);
+    }
+    case "inside": {
+      if (typeof expression.shape !== "string" || typeof expression.coords !== "string") {
+        throw new RpUnsupportedError("inside");
+      }
+      const operand = expression.expressions?.[0];
+      const value = operand === undefined ? null : evaluate(operand);
+      const member = value?.values[0];
+      if (value === null || typeof member !== "string") {
+        return null;
+      }
+      const point = parsePoint(member);
+      if (point === null) {
+        return null;
+      }
+      return booleanValue(pointInShape(expression.shape, parseCoords(expression.coords), point));
+    }
+    case "member": {
+      const [needleExpression, containerExpression] = expression.expressions ?? [];
+      if (needleExpression === undefined || containerExpression === undefined) {
+        return null;
+      }
+      const needle = evaluate(needleExpression);
+      const container = evaluate(containerExpression);
+      if (needle === null || container === null) {
+        return null;
+      }
+      const scalar = needle.values[0];
+      if (scalar === undefined) {
+        return null;
+      }
+      const baseType = container.baseType ?? needle.baseType;
+      return booleanValue(container.values.some((member) => scalarsEqual(member, scalar, baseType, env.normalization)));
+    }
+    case "multiple":
+    case "ordered": {
+      const members = [];
+      let baseType;
+      for (const child of expression.expressions ?? []) {
+        const value = evaluate(child);
+        if (value === null) {
+          continue;
+        }
+        baseType ??= value.baseType;
+        members.push(...value.values);
+      }
+      if (members.length === 0) {
+        return null;
+      }
+      return rpValue(expression.kind, members, baseType);
+    }
+    case "randomInteger": {
+      if (!env.random) {
+        throw new RpUnsupportedError(expression.kind);
+      }
+      const min = expression.min ?? 0;
+      const max = expression.max ?? min;
+      const step = expression.step ?? 1;
+      const count = Math.max(1, Math.floor((max - min) / step) + 1);
+      return { cardinality: "single", baseType: "integer", values: [min + Math.floor(env.random() * count) * step] };
+    }
+    case "randomFloat": {
+      if (!env.random) {
+        throw new RpUnsupportedError(expression.kind);
+      }
+      const min = expression.min ?? 0;
+      const max = expression.max ?? min;
+      return floatValue(min + env.random() * (max - min));
+    }
+    case "testVariables": {
+      if (!env.testVariables) {
+        throw new RpUnsupportedError(expression.kind);
+      }
+      return env.testVariables(expression);
+    }
+    case "customOperator": {
+      const implementation = env.customOperators?.[expression.class ?? ""];
+      if (!implementation) {
+        throw new RpUnsupportedError(expression.kind);
+      }
+      return implementation((expression.expressions ?? []).map(evaluate), expression);
+    }
+    case "numberCorrect":
+    case "numberIncorrect":
+    case "numberPresented":
+    case "numberResponded":
+    case "numberSelected": {
+      if (!env.testAggregate) {
+        throw new RpUnsupportedError(expression.kind);
+      }
+      return env.testAggregate(expression);
+    }
+    case "random": {
+      if (!env.random) {
+        throw new RpUnsupportedError(expression.kind);
+      }
+      const container = expression.expressions?.[0] === undefined ? null : evaluate(expression.expressions[0]);
+      if (container === null || container.values.length === 0) {
+        return null;
+      }
+      const pick = container.values[Math.floor(env.random() * container.values.length)];
+      return rpValue("single", [pick], container.baseType);
+    }
+    default:
+      throw new RpUnsupportedError(expression.kind);
+  }
+}
+function collectExpressionIssues(expression, allowedKinds, report, customOperatorClasses) {
+  if (expression.kind === "customOperator") {
+    if (!customOperatorClasses?.has(expression.class ?? "")) {
+      report(expression.kind);
+    }
+  } else if (!allowedKinds.has(expression.kind)) {
+    report(expression.kind);
+  }
+  for (const child of expression.expressions ?? []) {
+    collectExpressionIssues(child, allowedKinds, report, customOperatorClasses);
+  }
+}
+
+// src/rp/templates.ts
+var matchCorrectRules = [
+  {
+    kind: "responseCondition",
+    responseIf: {
+      expression: {
+        kind: "match",
+        expressions: [
+          { kind: "variable", identifier: "RESPONSE" },
+          { kind: "correct", identifier: "RESPONSE" }
+        ]
+      },
+      rules: [
+        {
+          kind: "setOutcomeValue",
+          identifier: "SCORE",
+          expression: { kind: "baseValue", baseType: "float", value: 1 }
+        }
+      ]
+    },
+    responseElse: {
+      rules: [
+        {
+          kind: "setOutcomeValue",
+          identifier: "SCORE",
+          expression: { kind: "baseValue", baseType: "float", value: 0 }
+        }
+      ]
+    }
+  }
+];
+var mapResponseRules = [
+  {
+    kind: "responseCondition",
+    responseIf: {
+      expression: { kind: "isNull", expressions: [{ kind: "variable", identifier: "RESPONSE" }] },
+      rules: [
+        {
+          kind: "setOutcomeValue",
+          identifier: "SCORE",
+          expression: { kind: "baseValue", baseType: "float", value: 0 }
+        }
+      ]
+    },
+    responseElse: {
+      rules: [
+        { kind: "setOutcomeValue", identifier: "SCORE", expression: { kind: "mapResponse", identifier: "RESPONSE" } }
+      ]
+    }
+  }
+];
+var mapResponsePointRules = [
+  {
+    kind: "responseCondition",
+    responseIf: {
+      expression: { kind: "isNull", expressions: [{ kind: "variable", identifier: "RESPONSE" }] },
+      rules: [
+        {
+          kind: "setOutcomeValue",
+          identifier: "SCORE",
+          expression: { kind: "baseValue", baseType: "float", value: 0 }
+        }
+      ]
+    },
+    responseElse: {
+      rules: [
+        {
+          kind: "setOutcomeValue",
+          identifier: "SCORE",
+          expression: { kind: "mapResponsePoint", identifier: "RESPONSE" }
+        }
+      ]
+    }
+  }
+];
+var cc2MatchBasicRules = [
+  {
+    kind: "responseCondition",
+    responseIf: {
+      expression: {
+        kind: "match",
+        expressions: [
+          { kind: "variable", identifier: "RESPONSE" },
+          { kind: "correct", identifier: "RESPONSE" }
+        ]
+      },
+      rules: [
+        { kind: "setOutcomeValue", identifier: "SCORE", expression: { kind: "variable", identifier: "MAXSCORE" } },
+        {
+          kind: "setOutcomeValue",
+          identifier: "FEEDBACKBASIC",
+          expression: { kind: "baseValue", baseType: "identifier", value: "correct" }
+        }
+      ]
+    },
+    responseElse: {
+      rules: [
+        {
+          kind: "setOutcomeValue",
+          identifier: "FEEDBACKBASIC",
+          expression: { kind: "baseValue", baseType: "identifier", value: "incorrect" }
+        }
+      ]
+    }
+  }
+];
+var cc2MapResponseRules = [
+  {
+    kind: "responseCondition",
+    responseIf: {
+      expression: { kind: "isNull", expressions: [{ kind: "variable", identifier: "RESPONSE" }] },
+      rules: [
+        {
+          kind: "setOutcomeValue",
+          identifier: "SCORE",
+          expression: { kind: "baseValue", baseType: "float", value: 0 }
+        }
+      ]
+    },
+    responseElse: {
+      rules: [
+        { kind: "setOutcomeValue", identifier: "SCORE", expression: { kind: "mapResponse", identifier: "RESPONSE" } }
+      ]
+    }
+  },
+  {
+    kind: "responseCondition",
+    responseIf: {
+      expression: {
+        kind: "equal",
+        toleranceMode: "exact",
+        expressions: [
+          { kind: "variable", identifier: "MAXSCORE" },
+          { kind: "variable", identifier: "SCORE" }
+        ]
+      },
+      rules: [
+        {
+          kind: "setOutcomeValue",
+          identifier: "FEEDBACK",
+          expression: { kind: "baseValue", baseType: "identifier", value: "correct" }
+        }
+      ]
+    },
+    responseElse: {
+      rules: [
+        {
+          kind: "setOutcomeValue",
+          identifier: "FEEDBACK",
+          expression: { kind: "baseValue", baseType: "identifier", value: "incorrect" }
+        }
+      ]
+    }
+  }
+];
+var templatesBySegment = new Map([
+  ["match_correct", matchCorrectRules],
+  ["map_response", mapResponseRules],
+  ["map_response_point", mapResponsePointRules],
+  ["CC2_match", matchCorrectRules],
+  ["CC2_match_basic", cc2MatchBasicRules],
+  ["CC2_map_response", cc2MapResponseRules]
+]);
+function resolveTemplate(uri) {
+  const segment = uri.split("/").at(-1)?.replace(/\.xml$/u, "") ?? "";
+  return templatesBySegment.get(segment) ?? null;
+}
+
+// src/rp/interpreter.ts
+var supportedRuleKinds = new Set(["responseCondition", "setOutcomeValue", "exitResponse"]);
+var rpExpressionKinds = new Set([...deterministicExpressionKinds, "random", "randomInteger", "randomFloat"]);
+
+class ExitResponseSignal extends Error {
+}
+function defaultOutcomes(declarations) {
+  const outcomes = new Map;
+  for (const declaration of declarations) {
+    if (declaration.defaultValue) {
+      outcomes.set(declaration.identifier, rpValue(declaration.cardinality, declaration.defaultValue.values.map((entry) => coerceScalar(entry.value, declaration.baseType)), declaration.baseType));
+      continue;
+    }
+    outcomes.set(declaration.identifier, isNumericBaseType(declaration.baseType) ? floatValue(0) : null);
+  }
+  return outcomes;
+}
+function executeResponseProcessing(view, context) {
+  const issues = [];
+  const declarationsById = new Map(context.responseDeclarations.map((declaration) => [declaration.identifier, declaration]));
+  const templateDeclarationsById = new Map((context.templateDeclarations ?? []).map((declaration) => [declaration.identifier, declaration]));
+  function initialOutcomes() {
+    const outcomes2 = defaultOutcomes(context.outcomeDeclarations);
+    for (const [identifier, prior] of Object.entries(context.priorOutcomes ?? {})) {
+      const declaration = context.outcomeDeclarations.find((entry) => entry.identifier === identifier);
+      outcomes2.set(identifier, fromFlatValue(prior, declaration?.cardinality ?? "single", declaration?.baseType));
+    }
+    return outcomes2;
+  }
+  let outcomes = initialOutcomes();
+  let rules = view?.rules ?? [];
+  if (view && !view.rules && view.template) {
+    const resolved = resolveTemplate(view.template);
+    if (resolved) {
+      rules = resolved;
+    } else {
+      issues.push({ type: "unsupported-rp", name: view.template, detail: "Unknown response-processing template URI." });
+    }
+  }
+  const env = {
+    lookupVariable: (identifier) => {
+      const declaration = declarationsById.get(identifier);
+      if (declaration) {
+        return fromResponse(declaration, context.responses[identifier] ?? null);
+      }
+      const templateDeclaration = templateDeclarationsById.get(identifier);
+      if (templateDeclaration) {
+        return fromFlatValue(context.templateValues?.[identifier] ?? null, templateDeclaration.cardinality, templateDeclaration.baseType);
+      }
+      return outcomes.get(identifier) ?? null;
+    },
+    responseDeclaration: (identifier) => declarationsById.get(identifier),
+    responseValue: (identifier) => context.responses[identifier] ?? null,
+    normalization: context.normalization,
+    random: context.random,
+    customOperators: context.customOperators
+  };
+  function branchTaken(branch) {
+    if (singleBoolean(evaluateExpression(branch.expression, env)) !== true) {
+      return false;
+    }
+    executeRules(branch.rules);
+    return true;
+  }
+  function executeRules(rules_) {
+    for (const rule of rules_) {
+      if (!supportedRuleKinds.has(rule.kind)) {
+        throw new RpUnsupportedError(rule.kind);
+      }
+      if (rule.kind === "exitResponse") {
+        throw new ExitResponseSignal;
+      }
+      if (rule.kind === "setOutcomeValue") {
+        if (rule.identifier !== undefined && rule.expression !== undefined) {
+          outcomes.set(rule.identifier, evaluateExpression(rule.expression, env));
+        }
+        continue;
+      }
+      if (rule.responseIf && branchTaken(rule.responseIf)) {
+        continue;
+      }
+      const elseIfTaken = (rule.responseElseIfs ?? []).some((branch) => branchTaken(branch));
+      if (!elseIfTaken && rule.responseElse) {
+        executeRules(rule.responseElse.rules);
+      }
+    }
+  }
+  try {
+    executeRules(rules);
+  } catch (error) {
+    if (error instanceof RpUnsupportedError) {
+      issues.push({ type: "unsupported-rp", name: error.kindName });
+      outcomes = initialOutcomes();
+    } else if (!(error instanceof ExitResponseSignal)) {
+      throw error;
+    }
+  }
+  return {
+    outcomes: Object.fromEntries([...outcomes].map(([identifier, value]) => [identifier, toOutcomeValue(value)])),
+    issues
+  };
+}
+function collectRpIssues(view, options) {
+  if (!view) {
+    return [];
+  }
+  const issues = [];
+  const seen = new Set;
+  function report(name, detail) {
+    if (!seen.has(name)) {
+      seen.add(name);
+      issues.push({ type: "unsupported-rp", name, ...detail === undefined ? {} : { detail } });
+    }
+  }
+  function walkRules(rules) {
+    for (const rule of rules) {
+      if (!supportedRuleKinds.has(rule.kind)) {
+        report(rule.kind);
+        continue;
+      }
+      if (rule.expression) {
+        collectExpressionIssues(rule.expression, rpExpressionKinds, report, options?.customOperatorClasses);
+      }
+      for (const branch of [rule.responseIf, ...rule.responseElseIfs ?? []]) {
+        if (branch) {
+          collectExpressionIssues(branch.expression, rpExpressionKinds, report, options?.customOperatorClasses);
+          walkRules(branch.rules);
+        }
+      }
+      if (rule.responseElse) {
+        walkRules(rule.responseElse.rules);
+      }
+    }
+  }
+  if (view.rules) {
+    walkRules(view.rules);
+  } else if (view.template) {
+    const resolved = resolveTemplate(view.template);
+    if (resolved === null) {
+      report(view.template, "Unknown response-processing template URI.");
+    }
+  }
+  return issues;
+}
+// src/rp/template-processing.ts
+var supportedTemplateRuleKinds = new Set([
+  "setTemplateValue",
+  "templateCondition",
+  "templateConstraint",
+  "setCorrectResponse",
+  "exitTemplate"
+]);
+var templateExpressionKinds = new Set([...deterministicExpressionKinds, ...randomExpressionKinds]);
+
+class ExitTemplateSignal extends Error {
+}
+
+class TemplateConstraintSignal extends Error {
+}
+var maxConstraintAttempts = 100;
+function mulberry32(seed) {
+  let state = seed >>> 0;
+  return () => {
+    state = state + 1831565813 >>> 0;
+    let t = state;
+    t = Math.imul(t ^ t >>> 15, t | 1);
+    t ^= t + Math.imul(t ^ t >>> 7, t | 61);
+    return ((t ^ t >>> 14) >>> 0) / 4294967296;
+  };
+}
+function executeTemplateProcessing(view, context) {
+  const issues = [];
+  const declarationsById = new Map(context.templateDeclarations.map((entry) => [entry.identifier, entry]));
+  const responseDeclarationsById = new Map(context.responseDeclarations.map((entry) => [entry.identifier, entry]));
+  const correctResponseOverrides = {};
+  function initialValues() {
+    const values = new Map;
+    for (const declaration of context.templateDeclarations) {
+      values.set(declaration.identifier, declaration.defaultValue ? rpValue(declaration.cardinality, declaration.defaultValue.values.map((entry) => coerceScalar(entry.value, declaration.baseType)), declaration.baseType) : null);
+    }
+    return values;
+  }
+  let templateValues = initialValues();
+  const env = {
+    lookupVariable: (identifier) => templateValues.get(identifier) ?? null,
+    responseDeclaration: (identifier) => responseDeclarationsById.get(identifier),
+    responseValue: () => null,
+    random: mulberry32(context.seed),
+    customOperators: context.customOperators
+  };
+  function branchTaken(branch) {
+    if (singleBoolean(evaluateExpression(branch.expression, env)) !== true) {
+      return false;
+    }
+    executeRules(branch.rules);
+    return true;
+  }
+  function executeRules(rules) {
+    for (const rule of rules) {
+      if (!supportedTemplateRuleKinds.has(rule.kind)) {
+        throw new RpUnsupportedError(rule.kind);
+      }
+      if (rule.kind === "exitTemplate") {
+        throw new ExitTemplateSignal;
+      }
+      if (rule.kind === "setTemplateValue") {
+        if (rule.identifier !== undefined && rule.expression !== undefined) {
+          const declaration = declarationsById.get(rule.identifier);
+          const value = evaluateExpression(rule.expression, env);
+          templateValues.set(rule.identifier, value === null || !declaration ? value : rpValue(declaration.cardinality, value.values, declaration.baseType ?? value.baseType));
+        }
+        continue;
+      }
+      if (rule.kind === "setCorrectResponse") {
+        if (rule.identifier !== undefined && rule.expression !== undefined) {
+          const value = evaluateExpression(rule.expression, env);
+          if (value !== null) {
+            correctResponseOverrides[rule.identifier] = {
+              values: value.values.map((member) => ({ value: String(member) }))
+            };
+          }
+        }
+        continue;
+      }
+      if (rule.kind === "templateConstraint") {
+        if (rule.expression !== undefined && singleBoolean(evaluateExpression(rule.expression, env)) !== true) {
+          throw new TemplateConstraintSignal;
+        }
+        continue;
+      }
+      if (rule.templateIf && branchTaken(rule.templateIf)) {
+        continue;
+      }
+      const elseIfTaken = (rule.templateElseIfs ?? []).some((branch) => branchTaken(branch));
+      if (!elseIfTaken && rule.templateElse) {
+        executeRules(rule.templateElse.rules);
+      }
+    }
+  }
+  for (let attempt = 0;attempt < maxConstraintAttempts; attempt += 1) {
+    try {
+      executeRules(view?.rules ?? []);
+      break;
+    } catch (error) {
+      if (error instanceof TemplateConstraintSignal) {
+        templateValues = initialValues();
+        for (const key of Object.keys(correctResponseOverrides)) {
+          delete correctResponseOverrides[key];
+        }
+        continue;
+      }
+      if (error instanceof RpUnsupportedError) {
+        issues.push({ type: "unsupported-rp", name: error.kindName });
+        templateValues = initialValues();
+      } else if (!(error instanceof ExitTemplateSignal)) {
+        throw error;
+      }
+      break;
+    }
+  }
+  return {
+    templateValues: Object.fromEntries([...templateValues].map(([identifier, value]) => [identifier, toOutcomeValue(value)])),
+    correctResponseOverrides,
+    issues
+  };
+}
+function applyCorrectResponseOverrides(declarations, overrides) {
+  return declarations.map((declaration) => {
+    const override = overrides[declaration.identifier];
+    return override ? { ...declaration, correctResponse: override } : declaration;
+  });
+}
+function collectTemplateIssues(view, options) {
+  if (!view) {
+    return [];
+  }
+  const issues = [];
+  const seen = new Set;
+  function report(name) {
+    if (!seen.has(name)) {
+      seen.add(name);
+      issues.push({ type: "unsupported-rp", name });
+    }
+  }
+  function walkRules(rules) {
+    for (const rule of rules) {
+      if (!supportedTemplateRuleKinds.has(rule.kind)) {
+        report(rule.kind);
+        continue;
+      }
+      if (rule.expression) {
+        collectExpressionIssues(rule.expression, templateExpressionKinds, report, options?.customOperatorClasses);
+      }
+      for (const branch of [rule.templateIf, ...rule.templateElseIfs ?? []]) {
+        if (branch) {
+          collectExpressionIssues(branch.expression, templateExpressionKinds, report, options?.customOperatorClasses);
+          walkRules(branch.rules);
+        }
+      }
+      if (rule.templateElse) {
+        walkRules(rule.templateElse.rules);
+      }
+    }
+  }
+  walkRules(view.rules);
+  return issues;
+}
+// src/store.ts
+function createAttemptStore(declarations, initialResponses, options) {
+  const seed = options?.seed ?? Math.floor(Math.random() * 2 ** 31);
+  const templateResult = options?.templateProcessing ? executeTemplateProcessing(options.templateProcessing, {
+    templateDeclarations: options.templateDeclarations ?? [],
+    responseDeclarations: declarations,
+    seed,
+    customOperators: options.customOperators
+  }) : null;
+  const effectiveDeclarations = templateResult ? applyCorrectResponseOverrides(declarations, templateResult.correctResponseOverrides) : declarations;
+  const declarationsById = new Map(effectiveDeclarations.map((declaration) => [declaration.identifier, declaration]));
+  const listeners = new Set;
+  const responseCollectors = new Map;
+  const rpRandom = mulberry32((seed ^ 2654435769) >>> 0);
+  let snapshot = {
+    responses: { ...initialResponses },
+    submitted: false,
+    scores: [],
+    outcomes: {},
+    templateValues: templateResult?.templateValues ?? {},
+    attemptCount: 0
+  };
+  function emit(next) {
+    snapshot = next;
+    for (const listener of listeners) {
+      listener();
+    }
+  }
+  function computeScores(responses) {
+    return [...declarationsById.values()].map((declaration) => scoreResponse(declaration, responses[declaration.identifier] ?? null, options?.normalization));
+  }
+  function computeOutcomes(responses, priorOutcomes) {
+    if (!options?.responseProcessing) {
+      return {};
+    }
+    return executeResponseProcessing(options.responseProcessing, {
+      responseDeclarations: effectiveDeclarations,
+      outcomeDeclarations: options.outcomeDeclarations ?? [],
+      responses,
+      normalization: options.normalization,
+      templateDeclarations: options.templateDeclarations,
+      templateValues: snapshot.templateValues,
+      priorOutcomes,
+      random: rpRandom,
+      customOperators: options.customOperators
+    }).outcomes;
+  }
+  return {
+    getSnapshot: () => snapshot,
+    subscribe: (listener) => {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
+    },
+    setResponse: (responseIdentifier, value) => {
+      if (snapshot.submitted) {
+        return;
+      }
+      emit({
+        ...snapshot,
+        responses: { ...snapshot.responses, [responseIdentifier]: value }
+      });
+    },
+    registerResponseCollector: (responseIdentifier, collector) => {
+      responseCollectors.set(responseIdentifier, collector);
+      return () => {
+        if (responseCollectors.get(responseIdentifier) === collector) {
+          responseCollectors.delete(responseIdentifier);
+        }
+      };
+    },
+    submit: () => {
+      if (snapshot.submitted) {
+        return snapshot.scores;
+      }
+      let collected = snapshot.responses;
+      for (const [responseIdentifier, collector] of responseCollectors) {
+        const value = collector();
+        if (value !== undefined) {
+          collected = { ...collected, [responseIdentifier]: value };
+        }
+      }
+      if (collected !== snapshot.responses) {
+        snapshot = { ...snapshot, responses: collected };
+      }
+      const scores = computeScores(snapshot.responses);
+      const priorOutcomes = options?.adaptive && snapshot.attemptCount > 0 ? snapshot.outcomes : undefined;
+      const outcomes = computeOutcomes(snapshot.responses, priorOutcomes);
+      const completionStatus = outcomes["completionStatus"] ?? outcomes["completion_status"];
+      const completed = !options?.adaptive || completionStatus === "completed";
+      let responses = snapshot.responses;
+      if (options?.adaptive && !completed) {
+        responses = { ...responses };
+        for (const declaration of effectiveDeclarations) {
+          if (declaration.baseType === "boolean") {
+            responses = { ...responses, [declaration.identifier]: null };
+          }
+        }
+      }
+      emit({
+        ...snapshot,
+        responses,
+        submitted: completed,
+        scores,
+        outcomes,
+        attemptCount: snapshot.attemptCount + 1
+      });
+      return scores;
+    },
+    reset: () => {
+      emit({
+        responses: { ...initialResponses },
+        submitted: false,
+        scores: [],
+        outcomes: {},
+        templateValues: snapshot.templateValues,
+        attemptCount: 0
+      });
+    }
+  };
+}
+// src/test/controller.ts
+var supportedOutcomeRuleKinds = new Set(["outcomeCondition", "setOutcomeValue", "exitTest"]);
+var testExpressionKinds = new Set([
+  ...deterministicExpressionKinds,
+  "testVariables",
+  "numberCorrect",
+  "numberIncorrect",
+  "numberPresented",
+  "numberResponded",
+  "numberSelected"
+]);
+
+class ExitTestSignal extends Error {
+}
+function inferBaseType(value) {
+  if (typeof value === "number") {
+    return "float";
+  }
+  if (typeof value === "boolean") {
+    return "boolean";
+  }
+  return;
+}
+function liftFlat(value) {
+  if (value === null || value === undefined) {
+    return null;
+  }
+  if (Array.isArray(value)) {
+    return fromFlatValue(value, "multiple", inferBaseType(value[0]));
+  }
+  return fromFlatValue(value, "single", inferBaseType(value));
+}
+var specSessionControlDefaults = {
+  maxAttempts: 1,
+  showFeedback: false,
+  allowReview: true,
+  showSolution: false,
+  allowComment: false,
+  allowSkipping: true,
+  validateResponses: false
+};
+function definedControl(control) {
+  return control ? Object.fromEntries(Object.entries(control).filter(([, value]) => value !== undefined)) : {};
+}
+function seededPick(pool, count, random) {
+  const indices = pool.map((_, index) => index);
+  for (let i = indices.length - 1;i > 0; i -= 1) {
+    const j = Math.floor(random() * (i + 1));
+    [indices[i], indices[j]] = [indices[j], indices[i]];
+  }
+  return indices.slice(0, Math.min(count, indices.length)).sort((a, b) => a - b).map((index) => pool[index]);
+}
+function applySelection(children, select, random) {
+  const required = children.filter((child) => child.required === true);
+  const optional = children.filter((child) => child.required !== true);
+  const needed = Math.max(0, select - required.length);
+  const picked = new Set([...required, ...seededPick(optional, needed, random)]);
+  return children.filter((child) => picked.has(child));
+}
+function applyOrdering(children, random) {
+  const result = children.map((child) => child.fixed === true ? child : null);
+  const movable = children.filter((child) => child.fixed !== true);
+  const shuffled = seededPick(movable, movable.length, random);
+  for (let i = shuffled.length - 1;i > 0; i -= 1) {
+    const j = Math.floor(random() * (i + 1));
+    [shuffled[i], shuffled[j]] = [shuffled[j], shuffled[i]];
+  }
+  let cursor = 0;
+  return result.map((slot) => slot ?? shuffled[cursor++]);
+}
+function resolveSection(section, partIdentifier, sectionPath, inheritedPreConditions, inheritedControl, random) {
+  const path = [...sectionPath, section.identifier];
+  const preConditions = [...inheritedPreConditions, ...section.preConditions ?? []];
+  const control = { ...inheritedControl, ...definedControl(section.itemSessionControl) };
+  let children = section.children;
+  if (section.selection) {
+    children = applySelection(children, section.selection.select, random);
+  }
+  if (section.ordering?.shuffle) {
+    children = applyOrdering(children, random);
+  }
+  const items = [];
+  for (const child of children) {
+    if (child.kind === "assessmentSection") {
+      items.push(...resolveSection(child, partIdentifier, path, preConditions, control, random));
+    } else {
+      items.push({
+        key: child.identifier,
+        ref: child,
+        partIdentifier,
+        sectionPath: path,
+        preConditions: [...preConditions, ...child.preConditions ?? []],
+        sessionControl: { ...specSessionControlDefaults, ...control, ...definedControl(child.itemSessionControl) },
+        ...child.timeLimits ? { timeLimits: child.timeLimits } : {}
+      });
+    }
+  }
+  return items;
+}
+function resolvePlan(view, seed) {
+  const random = mulberry32(seed);
+  return {
+    ...view.timeLimits ? { timeLimits: view.timeLimits } : {},
+    parts: view.testParts.map((part) => ({
+      identifier: part.identifier,
+      navigationMode: part.navigationMode,
+      submissionMode: part.submissionMode,
+      ...part.timeLimits ? { timeLimits: part.timeLimits } : {},
+      items: part.assessmentSections.flatMap((section) => resolveSection(section, part.identifier, [], [], definedControl(part.itemSessionControl), random))
+    }))
+  };
+}
+function createTestController(view, options) {
+  const plan = resolvePlan(view, options.seed);
+  const allItems = plan.parts.flatMap((part) => [...part.items]);
+  const partIndexByItemKey = new Map;
+  const itemsByKey = new Map;
+  plan.parts.forEach((part, partIndex) => {
+    for (const item of part.items) {
+      partIndexByItemKey.set(item.key, partIndex);
+      itemsByKey.set(item.key, item);
+    }
+  });
+  function attemptsOf(state, itemKey) {
+    return (state.attemptCounts ?? {})[itemKey] ?? 0;
+  }
+  function subsetItems(expression) {
+    const asList2 = (value) => typeof value === "string" ? [value] : value;
+    const includeCategory = asList2(expression.includeCategory);
+    const excludeCategory = asList2(expression.excludeCategory);
+    return allItems.filter((item) => {
+      if (expression.sectionIdentifier !== undefined && !item.sectionPath.includes(expression.sectionIdentifier)) {
+        return false;
+      }
+      const categories = item.ref.categories ?? [];
+      if (includeCategory !== undefined && !includeCategory.some((category) => categories.includes(category))) {
+        return false;
+      }
+      return !(excludeCategory !== undefined && excludeCategory.some((category) => categories.includes(category)));
+    });
+  }
+  function remainingAttempts(state, itemKey) {
+    const item = itemsByKey.get(itemKey);
+    if (!item) {
+      return 0;
+    }
+    const max = item.sessionControl.maxAttempts;
+    return max === 0 ? Number.POSITIVE_INFINITY : Math.max(0, max - attemptsOf(state, itemKey));
+  }
+  function defaultTestOutcomes() {
+    const outcomes = new Map;
+    for (const declaration of view.outcomeDeclarations ?? []) {
+      if (declaration.defaultValue) {
+        outcomes.set(declaration.identifier, rpValue(declaration.cardinality, declaration.defaultValue.values.map((entry) => coerceScalar(entry.value, declaration.baseType)), declaration.baseType));
+        continue;
+      }
+      outcomes.set(declaration.identifier, isNumericBaseType(declaration.baseType) ? floatValue(0) : null);
+    }
+    return outcomes;
+  }
+  function makeEnv(state, outcomes) {
+    return {
+      lookupVariable: (identifier) => {
+        const dot = identifier.indexOf(".");
+        if (dot !== -1) {
+          const itemKey = identifier.slice(0, dot);
+          const variableName = identifier.slice(dot + 1);
+          return liftFlat(state.itemOutcomes[itemKey]?.[variableName] ?? null);
+        }
+        if (outcomes?.has(identifier)) {
+          return outcomes.get(identifier) ?? null;
+        }
+        return liftFlat(state.testOutcomes[identifier] ?? null);
+      },
+      responseDeclaration: () => {
+        return;
+      },
+      responseValue: () => null,
+      testVariables: (expression) => {
+        const variableName = expression.variableIdentifier ?? expression.identifier ?? "";
+        const weightIdentifier = expression.weightIdentifier;
+        const members = [];
+        let baseType = expression.baseType;
+        for (const item of subsetItems(expression)) {
+          const value = state.itemOutcomes[item.key]?.[variableName];
+          if (value === undefined || value === null) {
+            continue;
+          }
+          const lifted = liftFlat(value);
+          if (lifted === null) {
+            continue;
+          }
+          if (weightIdentifier !== undefined && isNumericBaseType(lifted.baseType)) {
+            const weight = item.ref.weights?.find((entry) => entry.identifier === weightIdentifier)?.value ?? 1;
+            baseType = "float";
+            members.push(...lifted.values.map((entry) => Number(entry) * weight));
+            continue;
+          }
+          baseType ??= lifted.baseType;
+          members.push(...lifted.values);
+        }
+        return members.length === 0 ? null : rpValue("multiple", members, baseType);
+      },
+      testAggregate: (expression) => {
+        const subset = subsetItems(expression);
+        const integer = (value) => ({
+          cardinality: "single",
+          baseType: "integer",
+          values: [value]
+        });
+        const countIn = (list) => {
+          const flagged = new Set(list ?? []);
+          return subset.filter((item) => flagged.has(item.key)).length;
+        };
+        switch (expression.kind) {
+          case "numberSelected":
+            return integer(subset.length);
+          case "numberPresented":
+            return integer(countIn(state.presentedItems));
+          case "numberResponded":
+            return integer(countIn(state.respondedItems));
+          case "numberCorrect":
+            return integer(countIn(state.correctItems));
+          case "numberIncorrect":
+            return integer(countIn(state.incorrectItems));
+          default:
+            throw new RpUnsupportedError(expression.kind);
+        }
+      }
+    };
+  }
+  function conditionPasses(expression, state) {
+    try {
+      return singleBoolean(evaluateExpression(expression, makeEnv(state))) === true;
+    } catch (error) {
+      if (error instanceof RpUnsupportedError) {
+        return true;
+      }
+      throw error;
+    }
+  }
+  function preConditionsPass(item, state) {
+    return item.preConditions.every((expression) => conditionPasses(expression, state));
+  }
+  function runOutcomeProcessing(state) {
+    let outcomes = defaultTestOutcomes();
+    const env = makeEnv(state, outcomes);
+    function branchTaken(branch) {
+      if (singleBoolean(evaluateExpression(branch.expression, env)) !== true) {
+        return false;
+      }
+      executeRules(branch.rules);
+      return true;
+    }
+    function executeRules(rules) {
+      for (const rule of rules) {
+        if (!supportedOutcomeRuleKinds.has(rule.kind)) {
+          throw new RpUnsupportedError(rule.kind);
+        }
+        if (rule.kind === "exitTest") {
+          throw new ExitTestSignal;
+        }
+        if (rule.kind === "setOutcomeValue") {
+          if (rule.identifier !== undefined && rule.expression !== undefined) {
+            outcomes.set(rule.identifier, evaluateExpression(rule.expression, env));
+          }
+          continue;
+        }
+        if (rule.outcomeIf && branchTaken(rule.outcomeIf)) {
+          continue;
+        }
+        const elseIfTaken = (rule.outcomeElseIfs ?? []).some((branch) => branchTaken(branch));
+        if (!elseIfTaken && rule.outcomeElse) {
+          executeRules(rule.outcomeElse.rules);
+        }
+      }
+    }
+    try {
+      executeRules(view.outcomeProcessing?.rules ?? []);
+    } catch (error) {
+      if (error instanceof RpUnsupportedError) {
+        outcomes = defaultTestOutcomes();
+      } else if (!(error instanceof ExitTestSignal)) {
+        throw error;
+      }
+    }
+    return Object.fromEntries([...outcomes].map(([identifier, value]) => [identifier, toOutcomeValue(value)]));
+  }
+  function firstNavigable(state, partIndex, itemIndex) {
+    for (let p = partIndex;p < plan.parts.length; p += 1) {
+      const items = plan.parts[p].items;
+      for (let i = p === partIndex ? itemIndex : 0;i < items.length; i += 1) {
+        const item = items[i];
+        if (preConditionsPass(item, state)) {
+          return item;
+        }
+      }
+    }
+    return null;
+  }
+  function positionOf(itemKey) {
+    const partIndex = partIndexByItemKey.get(itemKey);
+    if (partIndex === undefined) {
+      return null;
+    }
+    const itemIndex = plan.parts[partIndex].items.findIndex((item) => item.key === itemKey);
+    return itemIndex === -1 ? null : { partIndex, itemIndex };
+  }
+  function withFlag(list, itemKey, present) {
+    const existing = list ?? [];
+    if (existing.includes(itemKey) === present) {
+      return existing;
+    }
+    return present ? [...existing, itemKey] : existing.filter((entry) => entry !== itemKey);
+  }
+  function applyResultFlags(state, itemKey, result) {
+    return {
+      ...state,
+      respondedItems: withFlag(state.respondedItems, itemKey, result.responded === true),
+      correctItems: withFlag(state.correctItems, itemKey, result.correct === true),
+      incorrectItems: withFlag(state.incorrectItems, itemKey, result.correct === false)
+    };
+  }
+  function markPresented(state, itemKey) {
+    return (state.presentedItems ?? []).includes(itemKey) ? state : { ...state, presentedItems: [...state.presentedItems ?? [], itemKey] };
+  }
+  function flushPending(state, partIndex) {
+    const pending = state.pendingItemResults ?? {};
+    const keys = Object.keys(pending).filter((key) => partIndex === null || partIndexByItemKey.get(key) === partIndex);
+    if (keys.length === 0) {
+      return state;
+    }
+    const itemOutcomes = { ...state.itemOutcomes };
+    const attemptCounts = { ...state.attemptCounts ?? {} };
+    const remaining = { ...pending };
+    let flagged = state;
+    for (const key of keys) {
+      const result = pending[key];
+      itemOutcomes[key] = result.outcomes;
+      attemptCounts[key] = (attemptCounts[key] ?? 0) + 1;
+      delete remaining[key];
+      flagged = applyResultFlags(flagged, key, result);
+    }
+    return { ...flagged, itemOutcomes, attemptCounts, pendingItemResults: remaining };
+  }
+  function ended(state) {
+    const flushed = flushPending(state, null);
+    return { ...flushed, status: "ended", currentItemKey: null, testOutcomes: runOutcomeProcessing(flushed) };
+  }
+  function moveToItem(state, item) {
+    if (item === null) {
+      return ended(state);
+    }
+    const fromPart = state.currentItemKey === null ? undefined : partIndexByItemKey.get(state.currentItemKey);
+    const toPart = partIndexByItemKey.get(item.key);
+    let next = state;
+    if (fromPart !== undefined && toPart !== fromPart) {
+      const flushed = flushPending(state, fromPart);
+      if (flushed !== state) {
+        next = { ...flushed, testOutcomes: runOutcomeProcessing(flushed) };
+      }
+    }
+    return markPresented({ ...next, currentItemKey: item.key }, item.key);
+  }
+  function nextState(state) {
+    if (state.status === "ended" || state.currentItemKey === null) {
+      return state;
+    }
+    const current = positionOf(state.currentItemKey);
+    if (!current) {
+      return ended(state);
+    }
+    const part = plan.parts[current.partIndex];
+    const currentItem = part.items[current.itemIndex];
+    if (part.navigationMode === "linear" && !currentItem.sessionControl.allowSkipping && !state.attemptedItems.includes(currentItem.key)) {
+      return state;
+    }
+    for (const branchRule of currentItem.ref.branchRules ?? []) {
+      if (!conditionPasses(branchRule.expression, state)) {
+        continue;
+      }
+      if (branchRule.target === "EXIT_TEST") {
+        return ended(state);
+      }
+      if (branchRule.target === "EXIT_TESTPART") {
+        return moveToItem(state, firstNavigable(state, current.partIndex + 1, 0));
+      }
+      if (branchRule.target === "EXIT_SECTION") {
+        const items = part.items;
+        const sectionKey = currentItem.sectionPath.join("/");
+        let index = current.itemIndex + 1;
+        while (index < items.length && items[index].sectionPath.join("/") === sectionKey) {
+          index += 1;
+        }
+        return moveToItem(state, firstNavigable(state, current.partIndex, index));
+      }
+      const target = positionOf(branchRule.target);
+      if (target && target.partIndex === current.partIndex) {
+        return moveToItem(state, firstNavigable(state, target.partIndex, target.itemIndex));
+      }
+    }
+    const destination = firstNavigable(state, current.partIndex, current.itemIndex + 1);
+    if (part.navigationMode === "nonlinear" && (destination === null || partIndexByItemKey.get(destination.key) !== current.partIndex)) {
+      const blocked = part.items.some((item) => !item.sessionControl.allowSkipping && !state.attemptedItems.includes(item.key) && preConditionsPass(item, state));
+      if (blocked) {
+        return state;
+      }
+    }
+    return moveToItem(state, destination);
+  }
+  const issues = [];
+  const seenIssues = new Set;
+  function report(name) {
+    if (!seenIssues.has(name)) {
+      seenIssues.add(name);
+      issues.push({ type: "unsupported-rp", name });
+    }
+  }
+  function walkOutcomeRules(rules) {
+    for (const rule of rules) {
+      if (!supportedOutcomeRuleKinds.has(rule.kind)) {
+        report(rule.kind);
+        continue;
+      }
+      if (rule.expression) {
+        collectExpressionIssues(rule.expression, testExpressionKinds, report);
+      }
+      for (const branch of [rule.outcomeIf, ...rule.outcomeElseIfs ?? []]) {
+        if (branch) {
+          collectExpressionIssues(branch.expression, testExpressionKinds, report);
+          walkOutcomeRules(branch.rules);
+        }
+      }
+      if (rule.outcomeElse) {
+        walkOutcomeRules(rule.outcomeElse.rules);
+      }
+    }
+  }
+  walkOutcomeRules(view.outcomeProcessing?.rules ?? []);
+  for (const item of allItems) {
+    for (const expression of item.preConditions) {
+      collectExpressionIssues(expression, testExpressionKinds, report);
+    }
+    for (const branchRule of item.ref.branchRules ?? []) {
+      collectExpressionIssues(branchRule.expression, testExpressionKinds, report);
+    }
+  }
+  return {
+    plan,
+    issues,
+    start: () => {
+      const initial = {
+        status: "in-progress",
+        currentItemKey: null,
+        itemOutcomes: {},
+        attemptedItems: [],
+        attemptCounts: {},
+        presentedItems: [],
+        respondedItems: [],
+        correctItems: [],
+        incorrectItems: [],
+        pendingItemResults: {},
+        testOutcomes: {}
+      };
+      return moveToItem({ ...initial, testOutcomes: runOutcomeProcessing(initial) }, firstNavigable(initial, 0, 0));
+    },
+    currentItem: (state) => state.currentItemKey === null ? null : allItems.find((item) => item.key === state.currentItemKey) ?? null,
+    canMoveTo: (state, itemKey) => {
+      if (state.status === "ended" || state.currentItemKey === null) {
+        return false;
+      }
+      const current = positionOf(state.currentItemKey);
+      const target = positionOf(itemKey);
+      if (!current || !target || target.partIndex !== current.partIndex) {
+        return false;
+      }
+      if (plan.parts[current.partIndex].navigationMode !== "nonlinear") {
+        return false;
+      }
+      return preConditionsPass(plan.parts[target.partIndex].items[target.itemIndex], state);
+    },
+    moveTo: (state, itemKey) => {
+      const current = positionOf(state.currentItemKey ?? "");
+      const target = positionOf(itemKey);
+      if (state.status === "ended" || !current || !target || target.partIndex !== current.partIndex || plan.parts[current.partIndex].navigationMode !== "nonlinear") {
+        return state;
+      }
+      return markPresented({ ...state, currentItemKey: itemKey }, itemKey);
+    },
+    canNext: (state) => nextState(state) !== state,
+    next: nextState,
+    remainingAttempts,
+    canSubmitItem: (state, itemKey) => state.status !== "ended" && remainingAttempts(state, itemKey) > 0,
+    submitItem: (state, itemKey, result) => {
+      if (state.status === "ended") {
+        return state;
+      }
+      const partIndex = partIndexByItemKey.get(itemKey);
+      if (partIndex !== undefined && plan.parts[partIndex].submissionMode === "simultaneous") {
+        if (attemptsOf(state, itemKey) > 0) {
+          return state;
+        }
+        return {
+          ...state,
+          pendingItemResults: { ...state.pendingItemResults ?? {}, [itemKey]: result },
+          attemptedItems: state.attemptedItems.includes(itemKey) ? state.attemptedItems : [...state.attemptedItems, itemKey]
+        };
+      }
+      if (result.adaptive !== true && remainingAttempts(state, itemKey) <= 0) {
+        return state;
+      }
+      const next = {
+        ...applyResultFlags(state, itemKey, result),
+        itemOutcomes: { ...state.itemOutcomes, [itemKey]: result.outcomes },
+        attemptedItems: state.attemptedItems.includes(itemKey) ? state.attemptedItems : [...state.attemptedItems, itemKey],
+        attemptCounts: { ...state.attemptCounts ?? {}, [itemKey]: attemptsOf(state, itemKey) + 1 }
+      };
+      return { ...next, testOutcomes: runOutcomeProcessing(next) };
+    },
+    end: (state) => state.status === "ended" ? state : ended(state),
+    visibleTestFeedbacks: (state) => (view.testFeedbacks ?? []).filter((feedback) => {
+      const accessOk = (feedback.access ?? "atEnd") === (state.status === "ended" ? "atEnd" : "during");
+      if (!accessOk) {
+        return false;
+      }
+      const outcome = state.testOutcomes[feedback.outcomeIdentifier] ?? null;
+      const matched = Array.isArray(outcome) ? outcome.map(String).includes(feedback.identifier) : outcome !== null && String(outcome) === feedback.identifier;
+      return matched !== (feedback.showHide === "hide");
+    })
+  };
+}
+// src/test/session-store.ts
+function collectCorrectResponseTargets(rules, into) {
+  for (const rule of rules ?? []) {
+    if (rule.kind === "setCorrectResponse" && rule.identifier !== undefined) {
+      into.add(rule.identifier);
+    }
+    for (const branch of [rule.templateIf, ...rule.templateElseIfs ?? []]) {
+      if (branch) {
+        collectCorrectResponseTargets(branch.rules, into);
+      }
+    }
+    if (rule.templateElse) {
+      collectCorrectResponseTargets(rule.templateElse.rules, into);
+    }
+  }
+}
+function scorableIdentifiers(view) {
+  const templated = new Set;
+  collectCorrectResponseTargets(view.templateProcessing?.rules, templated);
+  return new Set(view.responseDeclarations.filter((declaration) => declaration.correctResponse !== undefined || declaration.mapping !== undefined || declaration.areaMapping !== undefined || templated.has(declaration.identifier)).map((declaration) => declaration.identifier));
+}
+function hasResponse(value) {
+  if (value === null || value === undefined || value === "") {
+    return false;
+  }
+  if (isResponseRecord(value)) {
+    return Object.values(value).some((member) => member !== null && member !== "");
+  }
+  return !Array.isArray(value) || value.length > 0;
+}
+function resultFlags(attempt, scorable) {
+  const relevant = attempt.scores.filter((score) => scorable.has(score.identifier));
+  return {
+    ...relevant.length > 0 ? { correct: relevant.every((score) => score.correct) } : {},
+    responded: Object.values(attempt.responses).some(hasResponse)
+  };
+}
+function deriveItemSeed(seed, itemKey) {
+  let hash = (2166136261 ^ seed) >>> 0;
+  for (let index = 0;index < itemKey.length; index += 1) {
+    hash = Math.imul(hash ^ itemKey.charCodeAt(index), 16777619) >>> 0;
+  }
+  return hash;
+}
+function createTestSessionStore(controller, options) {
+  const listeners = new Set;
+  const planItemsByKey = new Map;
+  for (const part of controller.plan.parts) {
+    for (const item of part.items) {
+      planItemsByKey.set(item.key, item);
+    }
+  }
+  const itemViews = new Map;
+  const itemStores = new Map;
+  const forwardedAttempts = new Map;
+  let state = options.initialState ?? controller.start();
+  let snapshot = buildSnapshot();
+  function buildSnapshot() {
+    const currentItem = controller.currentItem(state);
+    return {
+      state,
+      currentItem,
+      currentItemView: currentItem === null ? null : itemView(currentItem.key),
+      visibleFeedbacks: controller.visibleTestFeedbacks(state)
+    };
+  }
+  function emit(next) {
+    state = next;
+    snapshot = buildSnapshot();
+    for (const listener of listeners) {
+      listener();
+    }
+  }
+  function itemView(itemKey) {
+    if (!itemViews.has(itemKey)) {
+      const planItem = planItemsByKey.get(itemKey);
+      itemViews.set(itemKey, planItem ? options.resolveItem(planItem.ref) : null);
+    }
+    return itemViews.get(itemKey) ?? null;
+  }
+  function itemStore(itemKey) {
+    if (itemStores.has(itemKey)) {
+      return itemStores.get(itemKey) ?? null;
+    }
+    const view = itemView(itemKey);
+    if (!view) {
+      itemStores.set(itemKey, null);
+      return null;
+    }
+    const store = createAttemptStore(view.responseDeclarations, {}, {
+      outcomeDeclarations: view.outcomeDeclarations,
+      responseProcessing: view.responseProcessing,
+      templateDeclarations: view.templateDeclarations,
+      templateProcessing: view.templateProcessing,
+      adaptive: view.adaptive,
+      seed: deriveItemSeed(options.seed, itemKey),
+      normalization: options.normalization,
+      customOperators: options.customOperators
+    });
+    const scorable = scorableIdentifiers(view);
+    store.subscribe(() => {
+      const attempt = store.getSnapshot();
+      if (attempt.submitted && forwardedAttempts.get(itemKey) !== attempt) {
+        forwardedAttempts.set(itemKey, attempt);
+        const next = controller.submitItem(state, itemKey, {
+          outcomes: attempt.outcomes,
+          ...resultFlags(attempt, scorable),
+          ...view.adaptive === true ? { adaptive: true } : {}
+        });
+        if (next !== state) {
+          emit(next);
+        }
+      }
+    });
+    itemStores.set(itemKey, store);
+    return store;
+  }
+  return {
+    controller,
+    subscribe: (listener) => {
+      listeners.add(listener);
+      return () => listeners.delete(listener);
+    },
+    getSnapshot: () => snapshot,
+    itemStore,
+    itemView,
+    next: () => emit(controller.next(state)),
+    canMoveTo: (itemKey) => controller.canMoveTo(state, itemKey),
+    moveTo: (itemKey) => emit(controller.moveTo(state, itemKey)),
+    end: () => emit(controller.end(state))
+  };
+}
+// src/runtime.ts
+import {
+  Fragment,
+  createContext,
+  createElement,
+  useContext,
+  useMemo,
+  useSyncExternalStore
+} from "react";
+function defineInteraction(descriptor) {
+  return descriptor;
+}
+var RuntimeContext = createContext(null);
+function useRuntimeContext() {
+  const context = useContext(RuntimeContext);
+  if (!context) {
+    throw new Error("QTI runtime components must be rendered inside an <ItemRenderer>.");
+  }
+  return context;
+}
+function responseIncludes(value, optionIdentifier) {
+  if (value === null) {
+    return false;
+  }
+  return typeof value === "string" ? value === optionIdentifier : Array.isArray(value) && value.includes(optionIdentifier);
+}
+function isCorrectOption(declaration, optionIdentifier) {
+  return Boolean(declaration?.correctResponse?.values.some((entry) => entry.value === optionIdentifier));
+}
+function isInteractionNode(node) {
+  return node.kind !== "xml" && typeof node.responseIdentifier === "string";
+}
+var feedbackKinds = new Set(["feedbackInline", "feedbackBlock"]);
+function isFeedbackNode(node) {
+  return feedbackKinds.has(node.kind);
+}
+var templateContentKinds = new Set(["templateInline", "templateBlock"]);
+function isTemplateContentNode(node) {
+  return templateContentKinds.has(node.kind);
+}
+function templateVisible(value, view) {
+  const matched = Array.isArray(value) ? value.includes(view.identifier) : value === view.identifier;
+  return matched !== (view.showHide === "hide");
+}
+var intrinsicLeafKinds = new Set(["text", "printedVariable"]);
+function createStaticStore(outcomes) {
+  const snapshot = {
+    responses: {},
+    submitted: true,
+    scores: [],
+    outcomes,
+    templateValues: {},
+    attemptCount: 1
+  };
+  return {
+    getSnapshot: () => snapshot,
+    subscribe: () => () => {},
+    setResponse: () => {},
+    registerResponseCollector: () => () => {},
+    submit: () => [],
+    reset: () => {}
+  };
+}
+function feedbackVisible(outcome, feedback, submitted) {
+  if (!submitted) {
+    return false;
+  }
+  const matched = Array.isArray(outcome) ? outcome.includes(feedback.identifier) : outcome === feedback.identifier;
+  return matched !== (feedback.showHide === "hide");
+}
+function createQtiRuntime(config) {
+  const model = config.contentModel ?? v0ContentModel;
+  const descriptorsByKind = new Map(config.interactions.map((descriptor) => [descriptor.kind, descriptor]));
+  const resolveAsset = config.assetResolver ?? ((href) => href);
+  function renderFlow(node, key, overrides, inMath = false) {
+    const isMath = inMath || node.name === model.mathRoot;
+    if (!isMath && !isAllowedFlowElement(model, node.name)) {
+      return null;
+    }
+    const attributes = isMath ? sanitizeMathAttributes(node.attributes) : sanitizeAttributes(model, node.name, node.attributes);
+    for (const name of model.urlAttributes) {
+      const value = attributes[name];
+      if (value !== undefined) {
+        attributes[name] = resolveAsset(value);
+      }
+    }
+    const children = node.children?.map((child, index) => renderNode(child, index, overrides, isMath));
+    return createElement(node.name, { key, ...attributes }, node.value ?? children);
+  }
+  function renderUnsupported(node, key) {
+    if (config.renderUnsupported) {
+      return createElement("span", { key }, config.renderUnsupported(node));
+    }
+    return createElement("div", { key, role: "note", "data-qti-unsupported": node.kind }, `This content requires an interaction type (${node.kind}) this runtime does not support.`);
+  }
+  function renderNode(node, key, overrides, inMath = false) {
+    const override = overrides?.[node.kind];
+    if (override) {
+      return createElement(Fragment, { key }, override(node, key));
+    }
+    if (isInteractionNode(node)) {
+      if (descriptorsByKind.has(node.kind) && config.skin[node.kind]) {
+        return createElement(InteractionHost, { key, node });
+      }
+      return renderUnsupported(node, key);
+    }
+    if (isFeedbackNode(node)) {
+      return createElement(FeedbackHost, {
+        key,
+        feedback: node,
+        element: node.kind === "feedbackInline" ? "span" : "div",
+        overrides
+      });
+    }
+    if (isTemplateContentNode(node)) {
+      return createElement(TemplateContentHost, {
+        key,
+        view: node,
+        element: node.kind === "templateInline" ? "span" : "div",
+        overrides
+      });
+    }
+    if (node.kind === "rubricBlock") {
+      const rubric = node;
+      if (!rubric.view?.includes("candidate")) {
+        return null;
+      }
+      return createElement("div", { key, "data-qti-rubric-block": true }, rubric.content?.map((child, index) => renderNode(child, index, overrides)));
+    }
+    if (node.kind === "printedVariable") {
+      const identifier = node.identifier;
+      return createElement(PrintedVariableHost, {
+        key,
+        identifier: typeof identifier === "string" ? identifier : ""
+      });
+    }
+    if (node.kind === "xml") {
+      return renderFlow(node, key, overrides, inMath);
+    }
+    const value = node.value;
+    return typeof value === "string" ? value : null;
+  }
+  function FeedbackHost({
+    feedback,
+    element,
+    overrides
+  }) {
+    const { store } = useRuntimeContext();
+    const snapshot = useSyncExternalStore(store.subscribe, store.getSnapshot, store.getSnapshot);
+    const outcome = snapshot.outcomes[feedback.outcomeIdentifier] ?? null;
+    if (!feedbackVisible(outcome, feedback, snapshot.submitted)) {
+      return null;
+    }
+    return createElement(element, { "data-qti-feedback": feedback.identifier }, feedback.content?.map((child, index) => renderNode(child, index, overrides)));
+  }
+  function TemplateContentHost({
+    view,
+    element,
+    overrides
+  }) {
+    const { store } = useRuntimeContext();
+    const snapshot = useSyncExternalStore(store.subscribe, store.getSnapshot, store.getSnapshot);
+    const value = snapshot.templateValues[view.templateIdentifier] ?? null;
+    if (!templateVisible(value, view)) {
+      return null;
+    }
+    return createElement(element, { "data-qti-template": view.identifier }, view.content?.map((child, index) => renderNode(child, index, overrides)));
+  }
+  function PrintedVariableHost({ identifier }) {
+    const { store } = useRuntimeContext();
+    const snapshot = useSyncExternalStore(store.subscribe, store.getSnapshot, store.getSnapshot);
+    const value = snapshot.templateValues[identifier] ?? snapshot.outcomes[identifier] ?? null;
+    const text = value === null ? "" : Array.isArray(value) ? value.join(" ") : String(value);
+    return createElement("span", { "data-qti-printed-variable": identifier }, text);
+  }
+  function ModalFeedbackHost({ feedback }) {
+    const { store } = useRuntimeContext();
+    const snapshot = useSyncExternalStore(store.subscribe, store.getSnapshot, store.getSnapshot);
+    const outcome = snapshot.outcomes[feedback.outcomeIdentifier] ?? null;
+    if (!feedbackVisible(outcome, feedback, snapshot.submitted)) {
+      return null;
+    }
+    return createElement("div", { role: "status", "data-qti-modal-feedback": feedback.identifier }, feedback.content?.map((child, index) => renderNode(child, index)));
+  }
+  function InteractionHost({ node }) {
+    const { store, declarationsById } = useRuntimeContext();
+    const snapshot = useSyncExternalStore(store.subscribe, store.getSnapshot, store.getSnapshot);
+    const responseIdentifier = node.responseIdentifier;
+    const declaration = declarationsById.get(responseIdentifier);
+    const cardinality = declaration?.cardinality ?? "single";
+    const value = snapshot.responses[responseIdentifier] ?? null;
+    const disabled = snapshot.submitted;
+    const answered = value !== null && !(typeof value === "string" && value.trim() === "") && !(Array.isArray(value) && value.length === 0);
+    let status = answered ? "answered" : "unanswered";
+    if (disabled) {
+      const scored = snapshot.scores.find((score) => score.identifier === responseIdentifier);
+      status = scored?.correct ? "correct" : "incorrect";
+    }
+    const setValue = (next) => {
+      store.setResponse(responseIdentifier, next);
+    };
+    const getOptionProps = (optionIdentifier) => {
+      const selected = responseIncludes(value, optionIdentifier);
+      let status2 = selected ? "selected" : "idle";
+      if (disabled) {
+        if (isCorrectOption(declaration, optionIdentifier)) {
+          status2 = "correct";
+        } else if (selected) {
+          status2 = "incorrect";
+        } else {
+          status2 = "idle";
+        }
+      }
+      return {
+        role: cardinality === "single" ? "radio" : "checkbox",
+        tabIndex: 0,
+        "aria-checked": selected,
+        "aria-disabled": disabled,
+        "data-status": status2,
+        onClick: () => {
+          if (disabled) {
+            return;
+          }
+          if (cardinality === "single") {
+            setValue(optionIdentifier);
+            return;
+          }
+          const current = value === null ? [] : typeof value === "string" ? [value] : Array.isArray(value) ? [...value] : [];
+          const next = selected ? current.filter((entry) => entry !== optionIdentifier) : [...current, optionIdentifier];
+          setValue(next);
+        }
+      };
+    };
+    const renderContent = (nodes, overrides) => nodes ? nodes.map((child, index) => renderNode(child, index, overrides)) : null;
+    const Skin = config.skin[node.kind];
+    if (!Skin) {
+      return null;
+    }
+    return createElement(Skin, {
+      node,
+      responseIdentifier,
+      value,
+      setValue,
+      disabled,
+      showFeedback: disabled,
+      status,
+      getOptionProps,
+      renderContent,
+      resolveAsset,
+      endAttempt: () => {
+        store.setResponse(responseIdentifier, "true");
+        store.submit();
+      },
+      registerResponseCollector: (collector) => store.registerResponseCollector(responseIdentifier, collector)
+    });
+  }
+  function ContentRenderer({ nodes, outcomes }) {
+    const store = useMemo(() => createStaticStore(outcomes ?? {}), [outcomes]);
+    const declarationsById = useMemo(() => new Map, []);
+    return createElement(RuntimeContext.Provider, { value: { store, declarationsById } }, nodes?.map((node, index) => renderNode(node, index)));
+  }
+  function ItemRenderer({ item, store: externalStore, seed, children }) {
+    const store = useMemo(() => externalStore ?? createAttemptStore(item.responseDeclarations, {}, {
+      outcomeDeclarations: item.outcomeDeclarations,
+      responseProcessing: item.responseProcessing,
+      templateDeclarations: item.templateDeclarations,
+      templateProcessing: item.templateProcessing,
+      adaptive: item.adaptive,
+      seed,
+      normalization: config.normalization,
+      customOperators: config.customOperators
+    }), [item, externalStore, seed]);
+    const declarationsById = useMemo(() => new Map(item.responseDeclarations.map((declaration) => [declaration.identifier, declaration])), [item]);
+    const body = (item.itemBody.content ?? []).map((node, index) => renderNode(node, index));
+    const modals = (item.modalFeedbacks ?? []).map((feedback, index) => createElement(ModalFeedbackHost, { key: index, feedback }));
+    return createElement(RuntimeContext.Provider, { value: { store, declarationsById } }, body, modals, children);
+  }
+  function useAttempt() {
+    const { store } = useRuntimeContext();
+    const snapshot = useSyncExternalStore(store.subscribe, store.getSnapshot, store.getSnapshot);
+    return {
+      ...snapshot,
+      submit: store.submit,
+      reset: store.reset
+    };
+  }
+  function canDeliver(item) {
+    const issues = [];
+    const seen = new Set;
+    function report(issue) {
+      const dedupeKey = `${issue.type}:${issue.name}:${issue.responseIdentifier ?? ""}`;
+      if (!seen.has(dedupeKey)) {
+        seen.add(dedupeKey);
+        issues.push(issue);
+      }
+    }
+    function walk(node) {
+      if (isFeedbackNode(node) || isTemplateContentNode(node) || node.kind === "rubricBlock") {
+        for (const child of node.content ?? []) {
+          walk(child);
+        }
+        return;
+      }
+      if (isInteractionNode(node)) {
+        const descriptor = descriptorsByKind.get(node.kind);
+        if (!descriptor || !config.skin[node.kind]) {
+          report({
+            type: "unsupported-interaction",
+            name: node.kind,
+            responseIdentifier: node.responseIdentifier
+          });
+          return;
+        }
+        const parsed = descriptor.schema.safeParse(node);
+        if (!parsed.success) {
+          const detail = parsed.error.issues[0]?.message;
+          report({
+            type: "invalid-interaction",
+            name: node.kind,
+            responseIdentifier: node.responseIdentifier,
+            ...detail !== undefined ? { detail } : {}
+          });
+        }
+        return;
+      }
+      if (node.kind === "xml") {
+        const xmlNode = node;
+        if (xmlNode.name === model.mathRoot) {
+          return;
+        }
+        if (!isAllowedFlowElement(model, xmlNode.name)) {
+          report({ type: "unsupported-element", name: xmlNode.name });
+        }
+        for (const child of xmlNode.children ?? []) {
+          walk(child);
+        }
+        return;
+      }
+      if (intrinsicLeafKinds.has(node.kind)) {
+        return;
+      }
+      report({ type: "unsupported-element", name: node.kind });
+    }
+    for (const node of item.itemBody.content ?? []) {
+      walk(node);
+    }
+    for (const feedback of item.modalFeedbacks ?? []) {
+      for (const child of feedback.content ?? []) {
+        walk(child);
+      }
+    }
+    const customOperatorClasses = new Set(Object.keys(config.customOperators ?? {}));
+    for (const issue of collectRpIssues(item.responseProcessing, { customOperatorClasses })) {
+      report(issue);
+    }
+    for (const issue of collectTemplateIssues(item.templateProcessing, { customOperatorClasses })) {
+      report(issue);
+    }
+    return { deliverable: issues.length === 0, issues };
+  }
+  return { ItemRenderer, ContentRenderer, useAttempt, canDeliver };
+}
+// src/pci/response.ts
+function scalarToString(value) {
+  if (Array.isArray(value)) {
+    return value.map(String).join(" ");
+  }
+  return String(value);
+}
+function payloadEntry(payload) {
+  if (typeof payload !== "object" || payload === null) {
+    return;
+  }
+  const values = Object.values(payload);
+  return values.length > 0 ? values[0] : undefined;
+}
+function recordField(entry) {
+  if (typeof entry !== "object" || entry === null) {
+    return null;
+  }
+  const { name, base } = entry;
+  if (typeof name !== "string") {
+    return null;
+  }
+  const raw = payloadEntry(base);
+  if (raw === undefined || raw === null) {
+    return [name, null];
+  }
+  return [name, typeof raw === "boolean" || typeof raw === "number" ? raw : scalarToString(raw)];
+}
+function pciResponseToValue(json) {
+  if (typeof json !== "object" || json === null) {
+    return null;
+  }
+  const shaped = json;
+  if (shaped.base !== undefined) {
+    const entry = payloadEntry(shaped.base);
+    return entry === undefined || entry === null ? null : scalarToString(entry);
+  }
+  if (shaped.list !== undefined) {
+    const entry = payloadEntry(shaped.list);
+    return Array.isArray(entry) ? entry.map(scalarToString) : null;
+  }
+  if (Array.isArray(shaped.record)) {
+    return Object.fromEntries(shaped.record.flatMap((entry) => {
+      const field = recordField(entry);
+      return field === null ? [] : [field];
+    }));
+  }
+  return null;
+}
+function fieldPciType(value) {
+  return typeof value === "boolean" ? "boolean" : typeof value === "number" ? "float" : "string";
+}
+var numericBaseTypes3 = new Set(["integer", "float"]);
+function bindScalar(value, baseType) {
+  if (numericBaseTypes3.has(baseType)) {
+    return Number(value);
+  }
+  if (baseType === "boolean") {
+    return value === "true";
+  }
+  if (baseType === "point") {
+    return value.split(/\s+/u).map(Number);
+  }
+  if (baseType === "pair" || baseType === "directedPair") {
+    return value.split(/\s+/u);
+  }
+  return value;
+}
+function valueToPciResponse(value, declaration) {
+  const baseType = declaration.baseType ?? "string";
+  if (value === null || value === undefined) {
+    return { base: null };
+  }
+  if (isResponseRecord(value)) {
+    return {
+      record: Object.entries(value).map(([name, member]) => member === null ? { name, base: null } : { name, base: { [fieldPciType(member)]: member } })
+    };
+  }
+  if (declaration.cardinality === "single") {
+    const single = Array.isArray(value) ? value[0] : value;
+    return single === undefined ? { base: null } : { base: { [baseType]: bindScalar(single, baseType) } };
+  }
+  const entries = Array.isArray(value) ? value : [value];
+  return { list: { [baseType]: entries.map((entry) => bindScalar(entry, baseType)) } };
+}
+// src/pci/registry.ts
+function defaultFetchText(url) {
+  return fetch(url).then((response) => {
+    if (!response.ok) {
+      throw new Error(`HTTP ${response.status} for ${url}`);
+    }
+    return response.text();
+  });
+}
+function createPciModuleRegistry(options = {}) {
+  const fetchText = options.fetchText ?? defaultFetchText;
+  const definitions = new Map;
+  const resolved = new Map;
+  const byTypeIdentifier = new Map;
+  let contextRegistrations = [];
+  const qtiCustomInteractionContext = {
+    register(module) {
+      contextRegistrations.push(module);
+      if (module.typeIdentifier !== undefined) {
+        byTypeIdentifier.set(module.typeIdentifier, module);
+      }
+    }
+  };
+  function resolveDependency(id, dependedOnBy, resolving) {
+    if (id === "qtiCustomInteractionContext") {
+      return qtiCustomInteractionContext;
+    }
+    if (resolved.has(id)) {
+      return resolved.get(id);
+    }
+    const definition = definitions.get(id);
+    if (!definition) {
+      throw new Error(`PCI module "${dependedOnBy}" depends on "${id}", which is not registered.`);
+    }
+    return instantiate(id, definition, resolving);
+  }
+  function instantiate(id, definition, resolving) {
+    if (resolving.has(id)) {
+      throw new Error(`Circular PCI module dependency involving "${id}".`);
+    }
+    resolving.add(id);
+    const dependencies = definition.dependencies.map((dependency) => resolveDependency(dependency, id, resolving));
+    const beforeCount = contextRegistrations.length;
+    const value = definition.factory(...dependencies);
+    const registered = contextRegistrations.length > beforeCount ? contextRegistrations.at(-1) : undefined;
+    const moduleValue = value ?? registered;
+    resolving.delete(id);
+    resolved.set(id, moduleValue);
+    const candidate = moduleValue;
+    if (candidate?.typeIdentifier !== undefined && typeof candidate.getInstance === "function") {
+      byTypeIdentifier.set(candidate.typeIdentifier, candidate);
+    }
+    return moduleValue;
+  }
+  function evaluate(source, context) {
+    const define = (...args) => {
+      const id = typeof args[0] === "string" ? args.shift() : context.id;
+      const dependencies = Array.isArray(args[0]) ? args.shift() : [];
+      const factoryArg = args[0];
+      const factory = typeof factoryArg === "function" ? factoryArg : () => factoryArg;
+      definitions.set(id, { dependencies, factory });
+    };
+    define.amd = {};
+    new Function("define", `"use strict";
+${source}`)(define);
+  }
+  function resolve(id) {
+    const fromType = byTypeIdentifier.get(id);
+    if (fromType) {
+      return fromType;
+    }
+    if (!resolved.has(id)) {
+      const definition = definitions.get(id);
+      if (!definition) {
+        for (const [pendingId, pending] of definitions) {
+          if (!resolved.has(pendingId)) {
+            try {
+              instantiate(pendingId, pending, new Set);
+            } catch {}
+          }
+        }
+        return byTypeIdentifier.get(id);
+      }
+      instantiate(id, definition, new Set);
+    }
+    const value = resolved.get(id);
+    return value && typeof value.getInstance === "function" ? value : undefined;
+  }
+  function toUrl(path) {
+    const withExtension = /\.[a-z]+$/iu.test(path) ? path : `${path}.js`;
+    return options.baseUrl ? new URL(withExtension, options.baseUrl).toString() : withExtension;
+  }
+  async function load(id, candidates) {
+    const existing = resolve(id);
+    if (existing) {
+      return existing;
+    }
+    const pathsEntry = options.paths?.[id];
+    const allCandidates = candidates.length > 0 ? candidates : pathsEntry !== undefined ? [pathsEntry] : [];
+    const failures = [];
+    for (const candidate of allCandidates) {
+      try {
+        evaluate(await fetchText(toUrl(candidate)), { id });
+        const module = resolve(id);
+        if (module) {
+          return module;
+        }
+        failures.push(`${candidate}: evaluated but did not register a PCI module`);
+      } catch (error) {
+        failures.push(`${candidate}: ${error instanceof Error ? error.message : String(error)}`);
+      }
+    }
+    throw new Error(`PCI module "${id}" could not be loaded. ${failures.join("; ") || "No candidate paths."}`);
+  }
+  return {
+    evaluate,
+    registerModule: (id, module) => {
+      resolved.set(id, module);
+      if (module.typeIdentifier !== undefined) {
+        byTypeIdentifier.set(module.typeIdentifier, module);
+      }
+    },
+    resolve,
+    load
+  };
+}
+// src/pci/markup.ts
+var voidElements = new Set([
+  "area",
+  "base",
+  "br",
+  "col",
+  "embed",
+  "hr",
+  "img",
+  "input",
+  "link",
+  "meta",
+  "source",
+  "track",
+  "wbr"
+]);
+var blockedElements = new Set(["script", "iframe", "object", "embed"]);
+var urlAttributes = new Set(["src", "href", "xlink:href", "poster", "data"]);
+function escapeText(value) {
+  return value.replace(/&/gu, "&amp;").replace(/</gu, "&lt;").replace(/>/gu, "&gt;");
+}
+function escapeAttribute(value) {
+  return escapeText(value).replace(/"/gu, "&quot;");
+}
+function isUnsafeMarkupAttribute(name, value) {
+  if (/^on/iu.test(name)) {
+    return true;
+  }
+  return urlAttributes.has(name.toLowerCase()) && /^\s*(?:javascript|vbscript|data:text\/html)/iu.test(value);
+}
+function serializeAttributes(attributes) {
+  if (!attributes) {
+    return "";
+  }
+  let result = "";
+  for (const [name, raw] of Object.entries(attributes)) {
+    const value = typeof raw === "string" ? raw : typeof raw === "number" || typeof raw === "boolean" ? String(raw) : undefined;
+    if (value !== undefined && !isUnsafeMarkupAttribute(name, value)) {
+      result += ` ${name}="${escapeAttribute(value)}"`;
+    }
+  }
+  return result;
+}
+function serializeNode(node) {
+  if (typeof node === "string") {
+    return escapeText(node);
+  }
+  if (node.kind === "text") {
+    return escapeText(node.value ?? "");
+  }
+  if (node.kind !== "xml") {
+    return "";
+  }
+  const xmlNode = node;
+  const name = xmlNode.name.toLowerCase();
+  if (blockedElements.has(name)) {
+    return "";
+  }
+  const attributes = serializeAttributes(xmlNode.attributes);
+  if (voidElements.has(name)) {
+    return `<${name}${attributes}>`;
+  }
+  const children = (xmlNode.children ?? []).map(serializeNode).join("");
+  const text = xmlNode.value !== undefined ? escapeText(xmlNode.value) : "";
+  return `<${name}${attributes}>${text}${children}</${name}>`;
+}
+function serializePciMarkup(nodes) {
+  return (nodes ?? []).map(serializeNode).join("");
+}
+// src/pci/mount.ts
+async function resolveModule(node, registry) {
+  const preRegistered = registry.resolve(node.customInteractionTypeIdentifier) ?? (node.module !== undefined ? registry.resolve(node.module) : undefined);
+  if (preRegistered) {
+    return preRegistered;
+  }
+  const declared = node.interactionModules?.modules ?? [];
+  for (const entry of declared) {
+    const candidates = [entry.primaryPath, entry.fallbackPath].filter((candidate) => candidate !== undefined);
+    await registry.load(entry.id, candidates);
+  }
+  if (declared.length === 0 && node.module !== undefined) {
+    await registry.load(node.module, []);
+  }
+  const loaded = registry.resolve(node.customInteractionTypeIdentifier) ?? (node.module !== undefined ? registry.resolve(node.module) : undefined) ?? (declared.length === 1 ? registry.resolve(declared[0].id) : undefined);
+  if (!loaded) {
+    throw new Error(`No PCI module registered for "${node.customInteractionTypeIdentifier}".`);
+  }
+  return loaded;
+}
+async function mountPci(options) {
+  const { container, node, registry } = options;
+  const module = await resolveModule(node, registry);
+  const markupHost = container.ownerDocument.createElement("div");
+  markupHost.className = "qti-interaction-markup";
+  markupHost.innerHTML = serializePciMarkup(node.interactionMarkup?.content);
+  container.appendChild(markupHost);
+  let resolveReady;
+  const ready = new Promise((resolve) => {
+    resolveReady = resolve;
+  });
+  const configuration = {
+    properties: node.properties ?? {},
+    responseIdentifier: node.responseIdentifier,
+    ...options.declaration ? { boundTo: { [node.responseIdentifier]: valueToPciResponse(options.boundValue ?? null, options.declaration) } } : {},
+    status: "interacting",
+    onready: (instance2) => resolveReady(instance2),
+    ondone: (_instance, response, state) => options.ondone?.(pciResponseToValue(response), state)
+  };
+  const returned = module.getInstance(container, configuration, options.state);
+  if (returned) {
+    resolveReady(returned);
+  }
+  const instance = await ready;
+  return {
+    instance,
+    collectResponse: () => pciResponseToValue(instance.getResponse()),
+    getState: () => instance.getState?.(),
+    unmount: () => {
+      instance.oncompleted?.();
+      container.replaceChildren();
+    }
+  };
+}
+// src/pci/interaction.ts
+import { z } from "zod";
+var interactionModuleSchema = z.object({
+  id: z.string().min(1),
+  primaryPath: z.string().optional(),
+  fallbackPath: z.string().optional()
+});
+var pciNodeSchema = z.object({
+  kind: z.literal("portableCustomInteraction"),
+  responseIdentifier: z.string().min(1),
+  customInteractionTypeIdentifier: z.string().min(1),
+  module: z.string().optional(),
+  properties: z.record(z.string(), z.string()).optional(),
+  interactionMarkup: z.object({ content: z.array(z.unknown()).optional() }).optional(),
+  interactionModules: z.object({
+    primaryConfiguration: z.string().optional(),
+    secondaryConfiguration: z.string().optional(),
+    modules: z.array(interactionModuleSchema).optional()
+  }).optional()
+});
+var portableCustomInteraction = defineInteraction({
+  kind: "portableCustomInteraction",
+  schema: pciNodeSchema,
+  scoring: "qti-standard",
+  initialResponse() {
+    return null;
+  }
+});
+// src/pci/skin.ts
+import { createElement as createElement2, useEffect, useRef, useState } from "react";
+function createPciSkin(options) {
+  return function PciHost(props) {
+    const node = props.node;
+    const containerRef = useRef(null);
+    const handleRef = useRef(null);
+    const propsRef = useRef(props);
+    propsRef.current = props;
+    const [mountError, setMountError] = useState(null);
+    useEffect(() => {
+      const container = containerRef.current;
+      if (!container) {
+        return;
+      }
+      let cancelled = false;
+      let mounted = null;
+      mountPci({
+        container,
+        node: propsRef.current.node,
+        registry: options.registry,
+        ondone: (value) => propsRef.current.setValue(value)
+      }).then((handle) => {
+        if (cancelled) {
+          handle.unmount();
+          return;
+        }
+        mounted = handle;
+        handleRef.current = handle;
+      }).catch((error) => {
+        if (!cancelled) {
+          setMountError(error instanceof Error ? error.message : String(error));
+        }
+      });
+      return () => {
+        cancelled = true;
+        mounted?.unmount();
+        handleRef.current = null;
+      };
+    }, []);
+    useEffect(() => propsRef.current.registerResponseCollector(() => handleRef.current?.collectResponse()), []);
+    return createElement2("div", {
+      "data-qti-interaction": "portableCustomInteraction",
+      "data-qti-pci-type": node.customInteractionTypeIdentifier,
+      className: node.class?.join(" ")
+    }, createElement2("div", { ref: containerRef, "data-qti-pci-container": "" }), mountError !== null ? createElement2("p", { role: "note", "data-qti-pci-error": "" }, `Custom interaction failed to load: ${mountError}`) : null);
+  };
+}
+// src/interactions/associate.ts
+import { z as z2 } from "zod";
+var associateInteractionNodeSchema = z2.object({
+  kind: z2.literal("associateInteraction"),
+  responseIdentifier: z2.string().min(1),
+  simpleAssociableChoices: z2.array(z2.looseObject({ identifier: z2.string().min(1), matchMax: z2.number().int().optional() })).min(2),
+  maxAssociations: z2.number().int().optional()
+});
+var associateInteraction = defineInteraction({
+  kind: "associateInteraction",
+  schema: associateInteractionNodeSchema,
+  scoring: "qti-standard",
+  initialResponse() {
+    return null;
+  }
+});
+
+// src/interactions/choice.ts
+import { z as z3 } from "zod";
+var choiceInteractionNodeSchema = z3.object({
+  kind: z3.literal("choiceInteraction"),
+  responseIdentifier: z3.string().min(1),
+  simpleChoices: z3.array(z3.object({ identifier: z3.string().min(1) })).min(1),
+  maxChoices: z3.number().int().optional()
+});
+var choiceInteraction = defineInteraction({
+  kind: "choiceInteraction",
+  schema: choiceInteractionNodeSchema,
+  scoring: "qti-standard",
+  initialResponse() {
+    return null;
+  }
+});
+
+// src/interactions/drawing.ts
+import { z as z4 } from "zod";
+var drawingInteractionNodeSchema = z4.object({
+  kind: z4.literal("drawingInteraction"),
+  responseIdentifier: z4.string().min(1),
+  object: z4.object({
+    data: z4.string().min(1),
+    width: z4.number().optional(),
+    height: z4.number().optional(),
+    type: z4.string().optional()
+  })
+});
+var drawingInteraction = defineInteraction({
+  kind: "drawingInteraction",
+  schema: drawingInteractionNodeSchema,
+  scoring: "qti-standard",
+  initialResponse() {
+    return null;
+  }
+});
+
+// src/interactions/end-attempt.ts
+import { z as z5 } from "zod";
+var endAttemptInteractionNodeSchema = z5.object({
+  kind: z5.literal("endAttemptInteraction"),
+  responseIdentifier: z5.string().min(1),
+  title: z5.string().min(1)
+});
+var endAttemptInteraction = defineInteraction({
+  kind: "endAttemptInteraction",
+  schema: endAttemptInteractionNodeSchema,
+  scoring: "qti-standard",
+  initialResponse() {
+    return null;
+  }
+});
+
+// src/interactions/extended-text.ts
+import { z as z6 } from "zod";
+var extendedTextInteractionNodeSchema = z6.object({
+  kind: z6.literal("extendedTextInteraction"),
+  responseIdentifier: z6.string().min(1),
+  expectedLength: z6.number().int().optional(),
+  expectedLines: z6.number().int().optional(),
+  placeholderText: z6.string().optional()
+});
+var extendedTextInteraction = defineInteraction({
+  kind: "extendedTextInteraction",
+  schema: extendedTextInteractionNodeSchema,
+  scoring: "qti-standard",
+  initialResponse() {
+    return null;
+  }
+});
+
+// src/interactions/gap-match.ts
+import { z as z7 } from "zod";
+var gapMatchInteractionNodeSchema = z7.object({
+  kind: z7.literal("gapMatchInteraction"),
+  responseIdentifier: z7.string().min(1),
+  gapTexts: z7.array(z7.looseObject({ identifier: z7.string().min(1), matchMax: z7.number().int().optional() })).min(1),
+  content: z7.array(z7.looseObject({ kind: z7.string().min(1) })).min(1)
+});
+var gapMatchInteraction = defineInteraction({
+  kind: "gapMatchInteraction",
+  schema: gapMatchInteractionNodeSchema,
+  scoring: "qti-standard",
+  initialResponse() {
+    return null;
+  }
+});
+
+// src/interactions/graphic.ts
+import { z as z8 } from "zod";
+var objectSchema = z8.object({
+  data: z8.string().min(1),
+  width: z8.number().optional(),
+  height: z8.number().optional(),
+  type: z8.string().optional()
+});
+var hotspotSchema = z8.looseObject({
+  identifier: z8.string().min(1),
+  shape: z8.string().min(1),
+  coords: z8.array(z8.number())
+});
+function nullInitial() {
+  return null;
+}
+var hotspotInteraction = defineInteraction({
+  kind: "hotspotInteraction",
+  schema: z8.object({
+    kind: z8.literal("hotspotInteraction"),
+    responseIdentifier: z8.string().min(1),
+    object: objectSchema,
+    hotspotChoices: z8.array(hotspotSchema).min(1),
+    maxChoices: z8.number().int().optional()
+  }),
+  scoring: "qti-standard",
+  initialResponse: nullInitial
+});
+var graphicOrderInteraction = defineInteraction({
+  kind: "graphicOrderInteraction",
+  schema: z8.object({
+    kind: z8.literal("graphicOrderInteraction"),
+    responseIdentifier: z8.string().min(1),
+    object: objectSchema,
+    hotspotChoices: z8.array(hotspotSchema).min(1)
+  }),
+  scoring: "qti-standard",
+  initialResponse: nullInitial
+});
+var graphicAssociateInteraction = defineInteraction({
+  kind: "graphicAssociateInteraction",
+  schema: z8.object({
+    kind: z8.literal("graphicAssociateInteraction"),
+    responseIdentifier: z8.string().min(1),
+    object: objectSchema,
+    associableHotspots: z8.array(hotspotSchema).min(2),
+    maxAssociations: z8.number().int().optional()
+  }),
+  scoring: "qti-standard",
+  initialResponse: nullInitial
+});
+var graphicGapMatchInteraction = defineInteraction({
+  kind: "graphicGapMatchInteraction",
+  schema: z8.object({
+    kind: z8.literal("graphicGapMatchInteraction"),
+    responseIdentifier: z8.string().min(1),
+    object: objectSchema,
+    gapImgs: z8.array(z8.looseObject({ identifier: z8.string().min(1), object: objectSchema.optional() })).min(1),
+    associableHotspots: z8.array(hotspotSchema).min(1)
+  }),
+  scoring: "qti-standard",
+  initialResponse: nullInitial
+});
+var selectPointInteraction = defineInteraction({
+  kind: "selectPointInteraction",
+  schema: z8.object({
+    kind: z8.literal("selectPointInteraction"),
+    responseIdentifier: z8.string().min(1),
+    object: objectSchema,
+    maxChoices: z8.number().int().optional()
+  }),
+  scoring: "qti-standard",
+  initialResponse: nullInitial
+});
+var positionObjectStage = defineInteraction({
+  kind: "positionObjectStage",
+  schema: z8.object({
+    kind: z8.literal("positionObjectStage"),
+    responseIdentifier: z8.string().min(1),
+    stageObject: objectSchema,
+    object: objectSchema,
+    maxChoices: z8.number().int().optional()
+  }),
+  scoring: "qti-standard",
+  initialResponse: nullInitial
+});
+
+// src/interactions/hottext.ts
+import { z as z9 } from "zod";
+var hottextInteractionNodeSchema = z9.object({
+  kind: z9.literal("hottextInteraction"),
+  responseIdentifier: z9.string().min(1),
+  maxChoices: z9.number().int().optional(),
+  content: z9.array(z9.looseObject({ kind: z9.string().min(1) })).min(1)
+});
+var hottextInteraction = defineInteraction({
+  kind: "hottextInteraction",
+  schema: hottextInteractionNodeSchema,
+  scoring: "qti-standard",
+  initialResponse() {
+    return null;
+  }
+});
+
+// src/interactions/inline-choice.ts
+import { z as z10 } from "zod";
+var inlineChoiceInteractionNodeSchema = z10.object({
+  kind: z10.literal("inlineChoiceInteraction"),
+  responseIdentifier: z10.string().min(1),
+  inlineChoices: z10.array(z10.object({ identifier: z10.string().min(1) })).min(1)
+});
+var inlineChoiceInteraction = defineInteraction({
+  kind: "inlineChoiceInteraction",
+  schema: inlineChoiceInteractionNodeSchema,
+  scoring: "qti-standard",
+  initialResponse() {
+    return null;
+  }
+});
+
+// src/interactions/match.ts
+import { z as z11 } from "zod";
+var simpleMatchSetSchema = z11.object({
+  simpleAssociableChoices: z11.array(z11.looseObject({ identifier: z11.string().min(1), matchMax: z11.number().int().optional() })).min(1)
+});
+var matchInteractionNodeSchema = z11.object({
+  kind: z11.literal("matchInteraction"),
+  responseIdentifier: z11.string().min(1),
+  simpleMatchSets: z11.array(simpleMatchSetSchema).length(2),
+  maxAssociations: z11.number().int().optional()
+});
+var matchInteraction = defineInteraction({
+  kind: "matchInteraction",
+  schema: matchInteractionNodeSchema,
+  scoring: "qti-standard",
+  initialResponse() {
+    return null;
+  }
+});
+
+// src/interactions/media.ts
+import { z as z12 } from "zod";
+var mediaInteractionNodeSchema = z12.object({
+  kind: z12.literal("mediaInteraction"),
+  responseIdentifier: z12.string().min(1),
+  autostart: z12.boolean().optional(),
+  minPlays: z12.number().int().optional(),
+  maxPlays: z12.number().int().optional(),
+  loop: z12.boolean().optional(),
+  content: z12.array(z12.looseObject({ kind: z12.string().min(1) })).min(1)
+});
+var mediaInteraction = defineInteraction({
+  kind: "mediaInteraction",
+  schema: mediaInteractionNodeSchema,
+  scoring: "qti-standard",
+  initialResponse() {
+    return null;
+  }
+});
+
+// src/interactions/order.ts
+import { z as z13 } from "zod";
+var orderInteractionNodeSchema = z13.object({
+  kind: z13.literal("orderInteraction"),
+  responseIdentifier: z13.string().min(1),
+  simpleChoices: z13.array(z13.looseObject({ identifier: z13.string().min(1) })).min(1),
+  shuffle: z13.boolean().optional(),
+  orientation: z13.enum(["horizontal", "vertical"]).optional()
+});
+var orderInteraction = defineInteraction({
+  kind: "orderInteraction",
+  schema: orderInteractionNodeSchema,
+  scoring: "qti-standard",
+  initialResponse() {
+    return null;
+  }
+});
+
+// src/interactions/slider.ts
+import { z as z14 } from "zod";
+var sliderInteractionNodeSchema = z14.object({
+  kind: z14.literal("sliderInteraction"),
+  responseIdentifier: z14.string().min(1),
+  lowerBound: z14.number(),
+  upperBound: z14.number(),
+  step: z14.number().optional(),
+  stepLabel: z14.boolean().optional(),
+  orientation: z14.enum(["horizontal", "vertical"]).optional(),
+  reverse: z14.boolean().optional()
+});
+var sliderInteraction = defineInteraction({
+  kind: "sliderInteraction",
+  schema: sliderInteractionNodeSchema,
   scoring: "qti-standard",
   initialResponse() {
     return null;
@@ -356,13 +3767,13 @@ var inlineChoiceInteraction = defineInteraction({
 });
 
 // src/interactions/text-entry.ts
-import { z as z3 } from "zod";
-var textEntryInteractionNodeSchema = z3.object({
-  kind: z3.literal("textEntryInteraction"),
-  responseIdentifier: z3.string().min(1),
-  expectedLength: z3.number().int().optional(),
-  placeholderText: z3.string().optional(),
-  patternMask: z3.string().optional()
+import { z as z15 } from "zod";
+var textEntryInteractionNodeSchema = z15.object({
+  kind: z15.literal("textEntryInteraction"),
+  responseIdentifier: z15.string().min(1),
+  expectedLength: z15.number().int().optional(),
+  placeholderText: z15.string().optional(),
+  patternMask: z15.string().optional()
 });
 var textEntryInteraction = defineInteraction({
   kind: "textEntryInteraction",
@@ -373,31 +3784,964 @@ var textEntryInteraction = defineInteraction({
   }
 });
 
+// src/interactions/upload.ts
+import { z as z16 } from "zod";
+var uploadInteractionNodeSchema = z16.object({
+  kind: z16.literal("uploadInteraction"),
+  responseIdentifier: z16.string().min(1),
+  type: z16.string().optional()
+});
+var uploadInteraction = defineInteraction({
+  kind: "uploadInteraction",
+  schema: uploadInteractionNodeSchema,
+  scoring: "qti-standard",
+  initialResponse() {
+    return null;
+  }
+});
+
 // src/interactions/index.ts
 var qtiCoreInteractions = [
+  associateInteraction,
   choiceInteraction,
+  drawingInteraction,
+  endAttemptInteraction,
+  extendedTextInteraction,
+  gapMatchInteraction,
+  graphicAssociateInteraction,
+  graphicGapMatchInteraction,
+  graphicOrderInteraction,
+  hotspotInteraction,
+  hottextInteraction,
+  inlineChoiceInteraction,
+  matchInteraction,
+  mediaInteraction,
+  orderInteraction,
+  positionObjectStage,
+  selectPointInteraction,
+  sliderInteraction,
   textEntryInteraction,
-  inlineChoiceInteraction
+  uploadInteraction
 ];
+// src/reference-skin/associate.ts
+import { createElement as createElement3, useState as useState2 } from "react";
+
+// src/reference-skin/content.ts
+function textOf(nodes) {
+  if (!nodes) {
+    return "";
+  }
+  let text = "";
+  for (const node of nodes) {
+    const value = node.value;
+    if (typeof value === "string") {
+      text += value;
+    }
+    const children = node.children;
+    if (children) {
+      text += textOf(children);
+    }
+  }
+  return text;
+}
+
+// src/reference-skin/associate.ts
+function AssociateReferenceSkin(props) {
+  const node = props.node;
+  const choices = node.simpleAssociableChoices ?? [];
+  const pairs = Array.isArray(props.value) ? props.value : [];
+  const [first, setFirst] = useState2("");
+  const [second, setSecond] = useState2("");
+  function labelFor(identifier) {
+    const choice = choices.find((candidate) => candidate.identifier === identifier);
+    return choice ? textOf(choice.content) || choice.identifier : identifier;
+  }
+  function addPair() {
+    if (first === "" || second === "" || first === second) {
+      return;
+    }
+    const pair = `${first} ${second}`;
+    if (!pairs.includes(pair) && !pairs.includes(`${second} ${first}`)) {
+      props.setValue([...pairs, pair]);
+    }
+    setFirst("");
+    setSecond("");
+  }
+  function picker(value, setValue, label) {
+    return createElement3("select", {
+      value,
+      disabled: props.disabled,
+      "aria-label": label,
+      onChange: (event) => setValue(event.target.value)
+    }, createElement3("option", { key: "", value: "" }, ""), choices.map((choice) => createElement3("option", { key: choice.identifier, value: choice.identifier }, labelFor(choice.identifier))));
+  }
+  return createElement3("div", { "data-qti-interaction": "associateInteraction", "data-status": props.status }, node.prompt ? createElement3("div", { "data-qti-prompt": true }, props.renderContent(node.prompt.content)) : null, picker(first, setFirst, "First member"), picker(second, setSecond, "Second member"), createElement3("button", { type: "button", disabled: props.disabled, onClick: addPair }, "Add pair"), createElement3("ul", null, pairs.map((pair) => {
+    const [a, b] = pair.split(/\s+/u);
+    return createElement3("li", { key: pair, "data-qti-pair": pair }, `${labelFor(a ?? "")} ↔ ${labelFor(b ?? "")} `, createElement3("button", {
+      type: "button",
+      disabled: props.disabled,
+      "aria-label": `Remove pair ${pair}`,
+      onClick: () => props.setValue(pairs.filter((entry) => entry !== pair))
+    }, "×"));
+  })));
+}
+
+// src/reference-skin/choice.ts
+import { createElement as createElement4 } from "react";
+function ChoiceReferenceSkin(props) {
+  const node = props.node;
+  const choices = node.simpleChoices ?? [];
+  const isRadio = choices.length > 0 && props.getOptionProps(choices[0].identifier).role === "radio";
+  return createElement4("div", {
+    role: isRadio ? "radiogroup" : "group",
+    "data-qti-interaction": "choiceInteraction",
+    "data-status": props.status
+  }, node.prompt ? createElement4("div", { "data-qti-prompt": true }, props.renderContent(node.prompt.content)) : null, choices.map((choice) => {
+    const optionProps = props.getOptionProps(choice.identifier);
+    return createElement4("button", { key: choice.identifier, type: "button", disabled: props.disabled, ...optionProps }, props.renderContent(choice.content) ?? choice.identifier);
+  }));
+}
+
+// src/reference-skin/drawing.ts
+import {
+  createElement as createElement5,
+  useCallback,
+  useEffect as useEffect2,
+  useRef as useRef2
+} from "react";
+var strokeStyle = "#c2410c";
+var strokeWidth = 3;
+function DrawingReferenceSkin(props) {
+  const node = props.node;
+  const width = node.object.width ?? 400;
+  const height = node.object.height ?? 300;
+  const canvasRef = useRef2(null);
+  const drawingRef = useRef2(false);
+  const propsRef = useRef2(props);
+  propsRef.current = props;
+  const stageData = node.object.data;
+  const paintBackground = useCallback((canvas) => {
+    const context = canvas.getContext("2d");
+    if (!context) {
+      return;
+    }
+    context.clearRect(0, 0, canvas.width, canvas.height);
+    const image = new Image;
+    image.onload = () => {
+      context.drawImage(image, 0, 0, canvas.width, canvas.height);
+    };
+    image.src = propsRef.current.resolveAsset(stageData);
+  }, [stageData]);
+  useEffect2(() => {
+    if (canvasRef.current) {
+      paintBackground(canvasRef.current);
+    }
+  }, [paintBackground]);
+  const pointerPosition = (event) => {
+    const canvas = event.currentTarget;
+    const rect = canvas.getBoundingClientRect();
+    return {
+      x: (event.clientX - rect.left) / rect.width * canvas.width,
+      y: (event.clientY - rect.top) / rect.height * canvas.height
+    };
+  };
+  const handlePointerDown = (event) => {
+    if (props.disabled) {
+      return;
+    }
+    const context = event.currentTarget.getContext("2d");
+    if (!context) {
+      return;
+    }
+    drawingRef.current = true;
+    event.currentTarget.setPointerCapture(event.pointerId);
+    const { x, y } = pointerPosition(event);
+    context.strokeStyle = strokeStyle;
+    context.lineWidth = strokeWidth;
+    context.lineCap = "round";
+    context.beginPath();
+    context.moveTo(x, y);
+  };
+  const handlePointerMove = (event) => {
+    if (!drawingRef.current) {
+      return;
+    }
+    const context = event.currentTarget.getContext("2d");
+    if (!context) {
+      return;
+    }
+    const { x, y } = pointerPosition(event);
+    context.lineTo(x, y);
+    context.stroke();
+  };
+  const handlePointerUp = (event) => {
+    if (!drawingRef.current) {
+      return;
+    }
+    drawingRef.current = false;
+    props.setValue(event.currentTarget.toDataURL("image/png"));
+  };
+  const handleClear = () => {
+    if (props.disabled) {
+      return;
+    }
+    props.setValue(null);
+    if (canvasRef.current) {
+      paintBackground(canvasRef.current);
+    }
+  };
+  return createElement5("div", { "data-qti-interaction": "drawingInteraction", "data-status": props.status }, node.prompt ? createElement5("div", { "data-qti-prompt": true }, props.renderContent(node.prompt.content)) : null, createElement5("canvas", {
+    ref: canvasRef,
+    width,
+    height,
+    role: "img",
+    "aria-label": "Drawing surface",
+    "data-qti-drawing-stage": "",
+    style: { touchAction: "none", border: "1px solid #d1d5db", maxWidth: "100%" },
+    onPointerDown: handlePointerDown,
+    onPointerMove: handlePointerMove,
+    onPointerUp: handlePointerUp
+  }), createElement5("button", { type: "button", onClick: handleClear, disabled: props.disabled, "aria-disabled": props.disabled }, "Clear"));
+}
+
+// src/reference-skin/end-attempt.ts
+import { createElement as createElement6 } from "react";
+function EndAttemptReferenceSkin(props) {
+  const node = props.node;
+  return createElement6("button", {
+    type: "button",
+    disabled: props.disabled,
+    "data-qti-interaction": "endAttemptInteraction",
+    onClick: () => props.endAttempt()
+  }, node.title ?? "End attempt");
+}
+
+// src/reference-skin/extended-text.ts
+import { createElement as createElement7 } from "react";
+function ExtendedTextReferenceSkin(props) {
+  const node = props.node;
+  const value = typeof props.value === "string" ? props.value : "";
+  return createElement7("div", { "data-qti-interaction": "extendedTextInteraction", "data-status": props.status }, node.prompt ? createElement7("div", { "data-qti-prompt": true }, props.renderContent(node.prompt.content)) : null, createElement7("textarea", {
+    value,
+    rows: node.expectedLines ?? 4,
+    placeholder: node.placeholderText,
+    disabled: props.disabled,
+    "aria-disabled": props.disabled,
+    onChange: (event) => {
+      props.setValue(event.target.value === "" ? null : event.target.value);
+    }
+  }));
+}
+
+// src/reference-skin/gap-match.ts
+import { createElement as createElement8 } from "react";
+function GapMatchReferenceSkin(props) {
+  const node = props.node;
+  const gapTexts = node.gapTexts ?? [];
+  const pairs = Array.isArray(props.value) ? props.value : [];
+  function fillGap(gapIdentifier, gapTextIdentifier) {
+    const kept = pairs.filter((pair) => pair.split(/\s+/u)[1] !== gapIdentifier);
+    props.setValue(gapTextIdentifier === "" ? kept : [...kept, `${gapTextIdentifier} ${gapIdentifier}`]);
+  }
+  return createElement8("div", { "data-qti-interaction": "gapMatchInteraction", "data-status": props.status }, node.prompt ? createElement8("div", { "data-qti-prompt": true }, props.renderContent(node.prompt.content)) : null, props.renderContent(node.content, {
+    gap: (child, key) => {
+      const gapIdentifier = child.identifier ?? "";
+      const filledBy = pairs.find((pair) => pair.split(/\s+/u)[1] === gapIdentifier)?.split(/\s+/u)[0] ?? "";
+      return createElement8("select", {
+        key,
+        value: filledBy,
+        disabled: props.disabled,
+        "aria-label": `Gap ${gapIdentifier}`,
+        "data-qti-gap": gapIdentifier,
+        onChange: (event) => fillGap(gapIdentifier, event.target.value)
+      }, createElement8("option", { key: "", value: "" }, ""), gapTexts.map((gapText) => createElement8("option", { key: gapText.identifier, value: gapText.identifier }, textOf(gapText.content) || gapText.identifier)));
+    }
+  }));
+}
+
+// src/reference-skin/graphic-associate.ts
+import { Fragment as Fragment2, createElement as createElement10, useState as useState3 } from "react";
+
+// src/reference-skin/graphic-base.ts
+import { createElement as createElement9 } from "react";
+function shapeCenter(shape, coords) {
+  switch (shape) {
+    case "circle":
+    case "ellipse":
+      return { x: coords[0] ?? 0, y: coords[1] ?? 0 };
+    case "rect":
+      return { x: ((coords[0] ?? 0) + (coords[2] ?? 0)) / 2, y: ((coords[1] ?? 0) + (coords[3] ?? 0)) / 2 };
+    case "poly": {
+      let x = 0;
+      let y = 0;
+      const pointCount = Math.floor(coords.length / 2);
+      for (let i = 0;i < pointCount * 2; i += 2) {
+        x += coords[i] ?? 0;
+        y += coords[i + 1] ?? 0;
+      }
+      return pointCount === 0 ? { x: 0, y: 0 } : { x: x / pointCount, y: y / pointCount };
+    }
+    default:
+      return { x: 0, y: 0 };
+  }
+}
+function shapeElement(shape, coords, key, props) {
+  const base = { key, fill: "transparent", stroke: "currentColor", strokeWidth: 1, ...props };
+  switch (shape) {
+    case "circle":
+      return createElement9("circle", { ...base, cx: coords[0], cy: coords[1], r: coords[2] });
+    case "rect":
+      return createElement9("rect", {
+        ...base,
+        x: coords[0],
+        y: coords[1],
+        width: (coords[2] ?? 0) - (coords[0] ?? 0),
+        height: (coords[3] ?? 0) - (coords[1] ?? 0)
+      });
+    case "ellipse":
+      return createElement9("ellipse", { ...base, cx: coords[0], cy: coords[1], rx: coords[2], ry: coords[3] });
+    case "poly": {
+      const points = [];
+      for (let i = 0;i + 1 < coords.length; i += 2) {
+        points.push(`${coords[i]},${coords[i + 1]}`);
+      }
+      return createElement9("polygon", { ...base, points: points.join(" ") });
+    }
+    default:
+      return createElement9("rect", { ...base, x: 0, y: 0, width: "100%", height: "100%" });
+  }
+}
+function GraphicStage(props) {
+  const width = props.object.width ?? 0;
+  const height = props.object.height ?? 0;
+  return createElement9("div", { "data-qti-interaction": props.interaction, "data-status": props.status }, props.prompt, createElement9("div", { style: { position: "relative", display: "inline-block", lineHeight: 0 } }, createElement9("img", {
+    src: props.resolveAsset(props.object.data),
+    width: width || undefined,
+    height: height || undefined,
+    alt: ""
+  }), createElement9("svg", {
+    viewBox: `0 0 ${width || 100} ${height || 100}`,
+    width: width || undefined,
+    height: height || undefined,
+    style: { position: "absolute", inset: 0 },
+    onClick: props.onStageClick ? (event) => {
+      props.onStageClick?.({
+        x: Math.round(event.nativeEvent.offsetX),
+        y: Math.round(event.nativeEvent.offsetY)
+      });
+    } : undefined
+  }, props.overlay)), props.after);
+}
+
+// src/reference-skin/graphic-associate.ts
+function GraphicAssociateReferenceSkin(props) {
+  const node = props.node;
+  const pairs = Array.isArray(props.value) ? [...props.value] : [];
+  const [pending, setPending] = useState3(null);
+  const hotspots = node.associableHotspots ?? [];
+  const centersById = new Map(hotspots.map((hotspot) => [hotspot.identifier, shapeCenter(hotspot.shape, hotspot.coords)]));
+  if (!node.object) {
+    return null;
+  }
+  function clickHotspot(identifier) {
+    if (props.disabled) {
+      return;
+    }
+    if (pending === null) {
+      setPending(identifier);
+      return;
+    }
+    if (pending === identifier) {
+      setPending(null);
+      return;
+    }
+    const pair = `${pending} ${identifier}`;
+    const reversed = `${identifier} ${pending}`;
+    if (!pairs.includes(pair) && !pairs.includes(reversed)) {
+      props.setValue([...pairs, pair]);
+    }
+    setPending(null);
+  }
+  return createElement10(GraphicStage, {
+    object: node.object,
+    resolveAsset: props.resolveAsset,
+    interaction: "graphicAssociateInteraction",
+    status: props.status,
+    prompt: node.prompt ? createElement10("div", { "data-qti-prompt": true }, props.renderContent(node.prompt.content)) : null,
+    overlay: createElement10(Fragment2, null, pairs.map((pair) => {
+      const [a, b] = pair.split(/\s+/u);
+      const from = centersById.get(a ?? "");
+      const to = centersById.get(b ?? "");
+      if (!from || !to) {
+        return null;
+      }
+      return createElement10("line", {
+        key: pair,
+        x1: from.x,
+        y1: from.y,
+        x2: to.x,
+        y2: to.y,
+        stroke: "currentColor",
+        strokeWidth: 2,
+        "data-qti-pair": pair,
+        style: { pointerEvents: "none" }
+      });
+    }), hotspots.map((hotspot) => shapeElement(hotspot.shape, hotspot.coords, hotspot.identifier, {
+      role: "button",
+      tabIndex: 0,
+      "aria-label": hotspot.identifier,
+      "aria-pressed": pending === hotspot.identifier,
+      "data-status": pending === hotspot.identifier ? "selected" : "idle",
+      onClick: () => clickHotspot(hotspot.identifier),
+      style: { cursor: props.disabled ? "default" : "pointer" }
+    }))),
+    after: createElement10("ul", null, pairs.map((pair) => createElement10("li", { key: pair }, pair.replace(/\s+/u, " ↔ "), createElement10("button", {
+      type: "button",
+      disabled: props.disabled,
+      "aria-label": `Remove association ${pair}`,
+      onClick: () => props.setValue(pairs.filter((entry) => entry !== pair))
+    }, "×"))))
+  });
+}
+
+// src/reference-skin/graphic-gap-match.ts
+import { Fragment as Fragment3, createElement as createElement11, useState as useState4 } from "react";
+function GraphicGapMatchReferenceSkin(props) {
+  const node = props.node;
+  const pairs = Array.isArray(props.value) ? [...props.value] : [];
+  const [selectedGapImg, setSelectedGapImg] = useState4(null);
+  const gapImgs = node.gapImgs ?? [];
+  const gapImgsById = new Map(gapImgs.map((gapImg) => [gapImg.identifier, gapImg]));
+  if (!node.object) {
+    return null;
+  }
+  function placedIn(hotspotIdentifier) {
+    const pair = pairs.find((entry) => entry.split(/\s+/u)[1] === hotspotIdentifier);
+    return pair?.split(/\s+/u)[0] ?? null;
+  }
+  function clickHotspot(hotspotIdentifier) {
+    if (props.disabled) {
+      return;
+    }
+    const kept = pairs.filter((entry) => entry.split(/\s+/u)[1] !== hotspotIdentifier);
+    if (selectedGapImg === null) {
+      if (kept.length !== pairs.length) {
+        props.setValue(kept.length === 0 ? null : kept);
+      }
+      return;
+    }
+    props.setValue([...kept, `${selectedGapImg} ${hotspotIdentifier}`]);
+    setSelectedGapImg(null);
+  }
+  return createElement11(GraphicStage, {
+    object: node.object,
+    resolveAsset: props.resolveAsset,
+    interaction: "graphicGapMatchInteraction",
+    status: props.status,
+    prompt: createElement11(Fragment3, null, node.prompt ? createElement11("div", { "data-qti-prompt": true }, props.renderContent(node.prompt.content)) : null, createElement11("div", { role: "group", "aria-label": "Gap images" }, gapImgs.map((gapImg) => createElement11("button", {
+      key: gapImg.identifier,
+      type: "button",
+      disabled: props.disabled,
+      "aria-pressed": selectedGapImg === gapImg.identifier,
+      "data-status": selectedGapImg === gapImg.identifier ? "selected" : "idle",
+      "data-qti-gap-img": gapImg.identifier,
+      onClick: () => setSelectedGapImg(selectedGapImg === gapImg.identifier ? null : gapImg.identifier)
+    }, gapImg.object ? createElement11("img", {
+      src: props.resolveAsset(gapImg.object.data),
+      width: gapImg.object.width,
+      height: gapImg.object.height,
+      alt: gapImg.identifier
+    }) : gapImg.label ?? gapImg.identifier)))),
+    overlay: (node.associableHotspots ?? []).map((hotspot) => {
+      const placed = placedIn(hotspot.identifier);
+      const placedEntry = placed === null ? undefined : gapImgsById.get(placed);
+      const placedObject = placedEntry?.object;
+      const center = shapeCenter(hotspot.shape, hotspot.coords);
+      return createElement11(Fragment3, { key: hotspot.identifier }, shapeElement(hotspot.shape, hotspot.coords, `${hotspot.identifier}-shape`, {
+        role: "button",
+        tabIndex: 0,
+        "aria-label": `${hotspot.identifier}${placed === null ? "" : `, contains ${placed}`}`,
+        "data-status": placed === null ? "idle" : "selected",
+        onClick: () => clickHotspot(hotspot.identifier),
+        style: { cursor: props.disabled ? "default" : "pointer" }
+      }), placedObject ? createElement11("image", {
+        href: props.resolveAsset(placedObject.data),
+        x: center.x - (placedObject.width ?? 0) / 2,
+        y: center.y - (placedObject.height ?? 0) / 2,
+        width: placedObject.width,
+        height: placedObject.height,
+        style: { pointerEvents: "none" }
+      }) : placedEntry ? createElement11("text", {
+        x: center.x,
+        y: center.y,
+        textAnchor: "middle",
+        dominantBaseline: "middle",
+        style: { pointerEvents: "none" }
+      }, placedEntry.label ?? placedEntry.identifier) : null);
+    })
+  });
+}
+
+// src/reference-skin/graphic-order.ts
+import { Fragment as Fragment4, createElement as createElement12 } from "react";
+function GraphicOrderReferenceSkin(props) {
+  const node = props.node;
+  const order = Array.isArray(props.value) ? [...props.value] : [];
+  if (!node.object) {
+    return null;
+  }
+  function toggle(identifier) {
+    if (props.disabled) {
+      return;
+    }
+    const next = order.includes(identifier) ? order.filter((entry) => entry !== identifier) : [...order, identifier];
+    props.setValue(next.length === 0 ? null : next);
+  }
+  return createElement12(GraphicStage, {
+    object: node.object,
+    resolveAsset: props.resolveAsset,
+    interaction: "graphicOrderInteraction",
+    status: props.status,
+    prompt: node.prompt ? createElement12("div", { "data-qti-prompt": true }, props.renderContent(node.prompt.content)) : null,
+    overlay: (node.hotspotChoices ?? []).map((hotspot) => {
+      const position = order.indexOf(hotspot.identifier);
+      const center = shapeCenter(hotspot.shape, hotspot.coords);
+      return createElement12(Fragment4, { key: hotspot.identifier }, shapeElement(hotspot.shape, hotspot.coords, `${hotspot.identifier}-shape`, {
+        role: "button",
+        tabIndex: 0,
+        "aria-label": `${hotspot.identifier}${position === -1 ? "" : `, position ${position + 1}`}`,
+        "data-status": position === -1 ? "idle" : "selected",
+        onClick: () => toggle(hotspot.identifier),
+        style: { cursor: props.disabled ? "default" : "pointer" }
+      }), position === -1 ? null : createElement12("text", {
+        x: center.x,
+        y: center.y,
+        textAnchor: "middle",
+        dominantBaseline: "central",
+        "data-qti-order-badge": hotspot.identifier,
+        style: { pointerEvents: "none" }
+      }, String(position + 1)));
+    })
+  });
+}
+
+// src/reference-skin/hotspot.ts
+import { createElement as createElement13 } from "react";
+function HotspotReferenceSkin(props) {
+  const node = props.node;
+  if (!node.object) {
+    return null;
+  }
+  return createElement13(GraphicStage, {
+    object: node.object,
+    resolveAsset: props.resolveAsset,
+    interaction: "hotspotInteraction",
+    status: props.status,
+    prompt: node.prompt ? createElement13("div", { "data-qti-prompt": true }, props.renderContent(node.prompt.content)) : null,
+    overlay: (node.hotspotChoices ?? []).map((hotspot) => {
+      const optionProps = props.getOptionProps(hotspot.identifier);
+      return shapeElement(hotspot.shape, hotspot.coords, hotspot.identifier, {
+        ...optionProps,
+        "aria-label": hotspot.identifier,
+        style: { cursor: props.disabled ? "default" : "pointer" }
+      });
+    })
+  });
+}
+
+// src/reference-skin/hottext.ts
+import { createElement as createElement14 } from "react";
+function HottextReferenceSkin(props) {
+  const node = props.node;
+  return createElement14("div", { "data-qti-interaction": "hottextInteraction", "data-status": props.status }, node.prompt ? createElement14("div", { "data-qti-prompt": true }, props.renderContent(node.prompt.content)) : null, props.renderContent(node.content, {
+    hottext: (child, key) => {
+      const view = child;
+      const identifier = view.identifier ?? "";
+      const optionProps = props.getOptionProps(identifier);
+      return createElement14("button", { key, type: "button", disabled: props.disabled, "data-qti-hottext": identifier, ...optionProps }, props.renderContent(view.content) ?? identifier);
+    }
+  }));
+}
+
+// src/reference-skin/inline-choice.ts
+import { createElement as createElement15 } from "react";
+function InlineChoiceReferenceSkin(props) {
+  const node = props.node;
+  const choices = node.inlineChoices ?? [];
+  const value = typeof props.value === "string" ? props.value : "";
+  return createElement15("select", {
+    value,
+    disabled: props.disabled,
+    "aria-disabled": props.disabled,
+    "data-qti-interaction": "inlineChoiceInteraction",
+    "data-status": props.status,
+    onChange: (event) => {
+      props.setValue(event.target.value === "" ? null : event.target.value);
+    }
+  }, createElement15("option", { key: "", value: "" }, ""), choices.map((choice) => createElement15("option", { key: choice.identifier, value: choice.identifier }, textOf(choice.content))));
+}
+
+// src/reference-skin/match.ts
+import { createElement as createElement16 } from "react";
+function MatchReferenceSkin(props) {
+  const node = props.node;
+  const rows = node.simpleMatchSets?.[0]?.simpleAssociableChoices ?? [];
+  const columns = node.simpleMatchSets?.[1]?.simpleAssociableChoices ?? [];
+  const pairs = Array.isArray(props.value) ? props.value : [];
+  function togglePair(pair) {
+    props.setValue(pairs.includes(pair) ? pairs.filter((entry) => entry !== pair) : [...pairs, pair]);
+  }
+  return createElement16("div", { "data-qti-interaction": "matchInteraction", "data-status": props.status }, node.prompt ? createElement16("div", { "data-qti-prompt": true }, props.renderContent(node.prompt.content)) : null, createElement16("table", null, createElement16("thead", null, createElement16("tr", null, createElement16("td", null), columns.map((column) => createElement16("th", { key: column.identifier, scope: "col" }, textOf(column.content) || column.identifier)))), createElement16("tbody", null, rows.map((row) => createElement16("tr", { key: row.identifier }, createElement16("th", { scope: "row" }, textOf(row.content) || row.identifier), columns.map((column) => {
+    const pair = `${row.identifier} ${column.identifier}`;
+    return createElement16("td", { key: column.identifier }, createElement16("input", {
+      type: "checkbox",
+      checked: pairs.includes(pair),
+      disabled: props.disabled,
+      "aria-label": `${textOf(row.content) || row.identifier} — ${textOf(column.content) || column.identifier}`,
+      "data-qti-pair": pair,
+      onChange: () => togglePair(pair)
+    }));
+  }))))));
+}
+
+// src/reference-skin/media.ts
+import { createElement as createElement17 } from "react";
+function findMediaElement(nodes) {
+  for (const node of nodes ?? []) {
+    if (node.kind === "xml") {
+      const xmlNode = node;
+      if (xmlNode.name === "audio" || xmlNode.name === "video") {
+        return xmlNode;
+      }
+      const nested = findMediaElement(xmlNode.children);
+      if (nested) {
+        return nested;
+      }
+    }
+  }
+  return null;
+}
+function MediaReferenceSkin(props) {
+  const node = props.node;
+  const media = findMediaElement(node.content);
+  const plays = typeof props.value === "string" ? Number(props.value) || 0 : 0;
+  const playsExhausted = node.maxPlays !== undefined && node.maxPlays > 0 && plays >= node.maxPlays;
+  if (!media) {
+    return createElement17("div", { "data-qti-interaction": "mediaInteraction", "data-status": props.status }, "No media element.");
+  }
+  const src = typeof media.attributes?.["src"] === "string" ? props.resolveAsset(media.attributes["src"]) : undefined;
+  return createElement17("div", { "data-qti-interaction": "mediaInteraction", "data-status": props.status, "data-qti-plays": plays }, node.prompt ? createElement17("div", { "data-qti-prompt": true }, props.renderContent(node.prompt.content)) : null, createElement17(media.name, {
+    src,
+    controls: true,
+    loop: node.loop ?? false,
+    onPlay: (event) => {
+      if (props.disabled || playsExhausted) {
+        event.currentTarget.pause();
+        return;
+      }
+      props.setValue(String(plays + 1));
+    }
+  }), playsExhausted ? createElement17("p", { role: "status" }, "No plays remaining.") : null);
+}
+
+// src/reference-skin/order.ts
+import { createElement as createElement18 } from "react";
+function OrderReferenceSkin(props) {
+  const node = props.node;
+  const choices = node.simpleChoices ?? [];
+  const declared = choices.map((choice) => choice.identifier);
+  const order = Array.isArray(props.value) ? [...props.value] : declared;
+  const choicesById = new Map(choices.map((choice) => [choice.identifier, choice]));
+  function move(index, delta) {
+    const target = index + delta;
+    if (target < 0 || target >= order.length) {
+      return;
+    }
+    const next = [...order];
+    const moved = next[index];
+    next[index] = next[target];
+    next[target] = moved;
+    props.setValue(next);
+  }
+  return createElement18("div", { "data-qti-interaction": "orderInteraction", "data-status": props.status }, node.prompt ? createElement18("div", { "data-qti-prompt": true }, props.renderContent(node.prompt.content)) : null, createElement18("ol", null, order.map((identifier, index) => createElement18("li", { key: identifier }, props.renderContent(choicesById.get(identifier)?.content) ?? identifier, createElement18("button", {
+    type: "button",
+    "aria-label": `Move ${identifier} up`,
+    disabled: props.disabled || index === 0,
+    onClick: () => move(index, -1)
+  }, "↑"), createElement18("button", {
+    type: "button",
+    "aria-label": `Move ${identifier} down`,
+    disabled: props.disabled || index === order.length - 1,
+    onClick: () => move(index, 1)
+  }, "↓")))));
+}
+
+// src/reference-skin/position-object.ts
+import { createElement as createElement19 } from "react";
+function PositionObjectReferenceSkin(props) {
+  const node = props.node;
+  const maxChoices = node.maxChoices ?? 1;
+  const points = props.value === null ? [] : typeof props.value === "string" ? [props.value] : Array.isArray(props.value) ? [...props.value] : [];
+  if (!node.stageObject || !node.object) {
+    return null;
+  }
+  const movable = node.object;
+  function stageClick(point) {
+    if (props.disabled) {
+      return;
+    }
+    const formatted = formatPoint(point);
+    if (maxChoices === 1) {
+      props.setValue(formatted);
+      return;
+    }
+    if (points.length < maxChoices) {
+      props.setValue([...points, formatted]);
+    }
+  }
+  return createElement19(GraphicStage, {
+    object: node.stageObject,
+    resolveAsset: props.resolveAsset,
+    interaction: "positionObjectStage",
+    status: props.status,
+    onStageClick: stageClick,
+    prompt: node.prompt ? createElement19("div", { "data-qti-prompt": true }, props.renderContent(node.prompt.content)) : null,
+    overlay: points.map((value, index) => {
+      const point = parsePoint(value);
+      if (!point) {
+        return null;
+      }
+      return createElement19("image", {
+        key: `${value}-${index}`,
+        href: props.resolveAsset(movable.data),
+        x: point.x - (movable.width ?? 0) / 2,
+        y: point.y - (movable.height ?? 0) / 2,
+        width: movable.width,
+        height: movable.height,
+        "data-qti-point": value,
+        style: { pointerEvents: "none" }
+      });
+    })
+  });
+}
+
+// src/reference-skin/select-point.ts
+import { Fragment as Fragment5, createElement as createElement20 } from "react";
+function SelectPointReferenceSkin(props) {
+  const node = props.node;
+  const maxChoices = node.maxChoices ?? 1;
+  const points = props.value === null ? [] : typeof props.value === "string" ? [props.value] : Array.isArray(props.value) ? [...props.value] : [];
+  if (!node.object) {
+    return null;
+  }
+  function stageClick(point) {
+    if (props.disabled) {
+      return;
+    }
+    const formatted = formatPoint(point);
+    if (maxChoices === 1) {
+      props.setValue(formatted);
+      return;
+    }
+    if (points.length < maxChoices) {
+      props.setValue([...points, formatted]);
+    }
+  }
+  return createElement20(GraphicStage, {
+    object: node.object,
+    resolveAsset: props.resolveAsset,
+    interaction: "selectPointInteraction",
+    status: props.status,
+    onStageClick: stageClick,
+    prompt: node.prompt ? createElement20("div", { "data-qti-prompt": true }, props.renderContent(node.prompt.content)) : null,
+    overlay: points.map((value, index) => {
+      const [x, y] = value.split(/\s+/u).map(Number);
+      return createElement20(Fragment5, { key: `${value}-${index}` }, createElement20("circle", {
+        cx: x,
+        cy: y,
+        r: 5,
+        fill: "currentColor",
+        "data-qti-point": value,
+        style: { pointerEvents: "none" }
+      }));
+    }),
+    after: createElement20("button", {
+      type: "button",
+      disabled: props.disabled || points.length === 0,
+      onClick: () => props.setValue(null)
+    }, "Clear points")
+  });
+}
+
+// src/reference-skin/slider.ts
+import { createElement as createElement21 } from "react";
+function SliderReferenceSkin(props) {
+  const node = props.node;
+  const lower = node.lowerBound ?? 0;
+  const value = typeof props.value === "string" && props.value !== "" ? props.value : String(lower);
+  return createElement21("div", { "data-qti-interaction": "sliderInteraction", "data-status": props.status }, node.prompt ? createElement21("div", { "data-qti-prompt": true }, props.renderContent(node.prompt.content)) : null, createElement21("input", {
+    type: "range",
+    min: lower,
+    max: node.upperBound ?? 100,
+    step: node.step ?? 1,
+    value,
+    disabled: props.disabled,
+    "aria-disabled": props.disabled,
+    onChange: (event) => {
+      props.setValue(event.target.value);
+    }
+  }), createElement21("output", null, props.value === null ? "—" : value));
+}
+
+// src/reference-skin/text-entry.ts
+import { createElement as createElement22 } from "react";
+function TextEntryReferenceSkin(props) {
+  const node = props.node;
+  const value = typeof props.value === "string" ? props.value : "";
+  return createElement22("input", {
+    type: "text",
+    value,
+    placeholder: node.placeholderText,
+    size: node.expectedLength,
+    disabled: props.disabled,
+    "aria-disabled": props.disabled,
+    "data-qti-interaction": "textEntryInteraction",
+    "data-status": props.status,
+    onChange: (event) => {
+      props.setValue(event.target.value === "" ? null : event.target.value);
+    }
+  });
+}
+
+// src/reference-skin/upload.ts
+import { createElement as createElement23 } from "react";
+function UploadReferenceSkin(props) {
+  const node = props.node;
+  return createElement23("div", { "data-qti-interaction": "uploadInteraction", "data-status": props.status }, node.prompt ? createElement23("div", { "data-qti-prompt": true }, props.renderContent(node.prompt.content)) : null, createElement23("input", {
+    type: "file",
+    accept: node.type,
+    disabled: props.disabled,
+    "aria-disabled": props.disabled,
+    onChange: (event) => {
+      const file = event.target.files?.[0];
+      if (!file) {
+        props.setValue(null);
+        return;
+      }
+      const reader = new FileReader;
+      reader.onload = () => {
+        props.setValue(typeof reader.result === "string" ? reader.result : null);
+      };
+      reader.readAsDataURL(file);
+    }
+  }));
+}
+
+// src/reference-skin/index.ts
+var referenceSkin = {
+  associateInteraction: AssociateReferenceSkin,
+  choiceInteraction: ChoiceReferenceSkin,
+  drawingInteraction: DrawingReferenceSkin,
+  endAttemptInteraction: EndAttemptReferenceSkin,
+  extendedTextInteraction: ExtendedTextReferenceSkin,
+  gapMatchInteraction: GapMatchReferenceSkin,
+  graphicAssociateInteraction: GraphicAssociateReferenceSkin,
+  graphicGapMatchInteraction: GraphicGapMatchReferenceSkin,
+  graphicOrderInteraction: GraphicOrderReferenceSkin,
+  hotspotInteraction: HotspotReferenceSkin,
+  hottextInteraction: HottextReferenceSkin,
+  inlineChoiceInteraction: InlineChoiceReferenceSkin,
+  matchInteraction: MatchReferenceSkin,
+  mediaInteraction: MediaReferenceSkin,
+  orderInteraction: OrderReferenceSkin,
+  positionObjectStage: PositionObjectReferenceSkin,
+  selectPointInteraction: SelectPointReferenceSkin,
+  sliderInteraction: SliderReferenceSkin,
+  textEntryInteraction: TextEntryReferenceSkin,
+  uploadInteraction: UploadReferenceSkin
+};
 
 // src/index.ts
 var qtiReactPackageName = "@conform-ed/qti-react";
 export {
+  valueToPciResponse,
   v0InteractionKinds,
   v0ContentModel,
+  uploadInteraction,
+  textOf,
   textEntryInteraction,
+  sliderInteraction,
+  serializePciMarkup,
+  selectPointInteraction,
   scoreResponse,
   sanitizeAttributes,
+  resolveTemplate,
+  referenceSkin,
   qtiReactPackageName,
   qtiCoreInteractions,
+  positionObjectStage,
+  portableCustomInteraction,
+  pointInShape,
+  pciResponseToValue,
+  parsePoint,
+  parseCoords,
+  orderInteraction,
+  mulberry32,
+  mountPci,
+  mediaInteraction,
+  matchInteraction,
   matchCorrect,
+  mapResponsePoint,
   mapResponse,
   isInteractionKind,
   isAllowedFlowElement,
   inlineChoiceInteraction,
+  hottextInteraction,
+  hotspotInteraction,
+  graphicOrderInteraction,
+  graphicGapMatchInteraction,
+  graphicAssociateInteraction,
+  gapMatchInteraction,
+  formatPoint,
   foldString,
+  extendedTextInteraction,
+  executeTemplateProcessing,
+  executeResponseProcessing,
+  endAttemptInteraction,
+  drawingInteraction,
   defineInteraction,
+  createTestSessionStore,
+  createTestController,
   createQtiRuntime,
+  createPciSkin,
+  createPciModuleRegistry,
   createAttemptStore,
-  choiceInteraction
+  collectTemplateIssues,
+  collectRpIssues,
+  choiceInteraction,
+  associateInteraction,
+  assessmentTestViewFromNormalized,
+  assessmentItemViewFromNormalized,
+  applyCorrectResponseOverrides,
+  UploadReferenceSkin,
+  TextEntryReferenceSkin,
+  SliderReferenceSkin,
+  SelectPointReferenceSkin,
+  PositionObjectReferenceSkin,
+  OrderReferenceSkin,
+  MediaReferenceSkin,
+  MatchReferenceSkin,
+  InlineChoiceReferenceSkin,
+  HottextReferenceSkin,
+  HotspotReferenceSkin,
+  GraphicStage,
+  GraphicOrderReferenceSkin,
+  GraphicGapMatchReferenceSkin,
+  GraphicAssociateReferenceSkin,
+  GapMatchReferenceSkin,
+  ExtendedTextReferenceSkin,
+  EndAttemptReferenceSkin,
+  DrawingReferenceSkin,
+  ChoiceReferenceSkin,
+  AssociateReferenceSkin
 };