@conform-ed/qti-react 0.0.18 → 0.0.20

package/dist/headless.js

@@ -3053,10 +3053,1941 @@ var referenceInteractionKinds = [
   "textEntryInteraction",
   "uploadInteraction"
 ];
+// src/item-score.ts
+function numericOutcome(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
+function effectiveItemScore(scores, outcomes) {
+  const scoreOutcome = numericOutcome(outcomes["SCORE"]);
+  const maxOutcome = numericOutcome(outcomes["MAXSCORE"]);
+  const summedMax = scores.reduce((total, score) => total + score.maxScore, 0);
+  if (scoreOutcome !== null) {
+    return { raw: scoreOutcome, max: maxOutcome ?? summedMax, fromOutcomes: true };
+  }
+  return {
+    raw: scores.reduce((total, score) => total + score.score, 0),
+    max: maxOutcome ?? summedMax,
+    fromOutcomes: false
+  };
+}
+// src/response-validity.ts
+var countConstraintKinds = ["minChoices", "maxChoices", "minAssociations", "maxAssociations", "minStrings"];
+function collectInteractionConstraints(content) {
+  const constraints = [];
+  function walk(node) {
+    const record = node;
+    if (isInteractionKind(v0ContentModel, node.kind) && typeof record["responseIdentifier"] === "string") {
+      const responseIdentifier = record["responseIdentifier"];
+      for (const kind of [...countConstraintKinds, "minPlays"]) {
+        const bound = record[kind];
+        if (typeof bound === "number" && bound > 0) {
+          constraints.push({ responseIdentifier, kind, bound });
+        }
+      }
+      const patternMask = record["patternMask"];
+      if (typeof patternMask === "string" && patternMask !== "") {
+        constraints.push({ responseIdentifier, kind: "patternMask", bound: patternMask });
+      }
+      return;
+    }
+    for (const key of ["content", "children"]) {
+      const nested = record[key];
+      if (Array.isArray(nested)) {
+        for (const child of nested) {
+          walk(child);
+        }
+      }
+    }
+  }
+  for (const node of content ?? []) {
+    walk(node);
+  }
+  return constraints;
+}
+function memberCount(value) {
+  if (value === null || value === undefined || value === "") {
+    return 0;
+  }
+  if (Array.isArray(value)) {
+    return value.filter((member) => member !== null && member !== "").length;
+  }
+  return 1;
+}
+function stringMembers(value) {
+  if (typeof value === "string") {
+    return value === "" ? [] : [value];
+  }
+  if (Array.isArray(value)) {
+    return value.filter((member) => typeof member === "string" && member !== "");
+  }
+  return [];
+}
+function violates(constraint, value) {
+  switch (constraint.kind) {
+    case "minChoices":
+    case "minAssociations":
+    case "minStrings":
+      return memberCount(value) < Number(constraint.bound);
+    case "maxChoices":
+    case "maxAssociations":
+      return memberCount(value) > Number(constraint.bound);
+    case "minPlays": {
+      const plays = typeof value === "number" ? value : 0;
+      return plays < Number(constraint.bound);
+    }
+    case "patternMask": {
+      const members = stringMembers(value);
+      if (members.length === 0) {
+        return false;
+      }
+      try {
+        const matches = HA(String(constraint.bound), { language: "xsd" });
+        return !members.every((member) => matches(member));
+      } catch {
+        return false;
+      }
+    }
+  }
+}
+function collectResponseViolations(constraints, responses) {
+  return constraints.filter((constraint) => {
+    const value = responses[constraint.responseIdentifier] ?? null;
+    return !isResponseRecord(value) && violates(constraint, value);
+  });
+}
+
+// src/store.ts
+function createAttemptStore(declarations, initialResponses, options) {
+  const seed = options?.seed ?? Math.floor(Math.random() * 2 ** 31);
+  const templateDeclarations = options?.templateDefaultValues ? applyTemplateDefaultOverrides(options.templateDeclarations ?? [], options.templateDefaultValues) : options?.templateDeclarations ?? [];
+  const templateResult = options?.templateProcessing ? executeTemplateProcessing(options.templateProcessing, {
+    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);
+  const now = options?.now ?? Date.now;
+  let activeMs = 0;
+  let runningSinceMs = now();
+  const activeSeconds = () => (activeMs + (runningSinceMs === null ? 0 : now() - runningSinceMs)) / 1000;
+  const completionStatusDeclared = (options?.outcomeDeclarations ?? []).some((declaration) => declaration.identifier === "completionStatus");
+  const maintainedOutcomes = () => completionStatusDeclared ? {} : { completionStatus: "unknown" };
+  const violationsOf = (responses) => options?.constraints ? collectResponseViolations(options.constraints, responses) : [];
+  const correctResponses = {};
+  for (const declaration of effectiveDeclarations) {
+    const values = declaration.correctResponse?.values;
+    if (values !== undefined) {
+      correctResponses[declaration.identifier] = declaration.cardinality === "single" ? values[0]?.value ?? null : values.map((entry) => entry.value);
+    }
+  }
+  let snapshot = {
+    responses: { ...initialResponses },
+    submitted: false,
+    scores: [],
+    outcomes: maintainedOutcomes(),
+    templateValues: templateResult?.templateValues ?? {},
+    attemptCount: 0,
+    durationSeconds: null,
+    responseViolations: violationsOf(initialResponses),
+    correctResponses
+  };
+  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, durationSeconds, priorOutcomes) {
+    if (!options?.responseProcessing) {
+      return {};
+    }
+    return executeResponseProcessing(options.responseProcessing, {
+      responseDeclarations: effectiveDeclarations,
+      outcomeDeclarations: options.outcomeDeclarations ?? [],
+      responses,
+      normalization: options.normalization,
+      templateDeclarations,
+      templateValues: snapshot.templateValues,
+      priorOutcomes,
+      random: rpRandom,
+      customOperators: options.customOperators,
+      duration: durationSeconds,
+      numAttempts: snapshot.attemptCount + 1,
+      ...typeof snapshot.outcomes["completionStatus"] === "string" ? { completionStatus: snapshot.outcomes["completionStatus"] } : {}
+    }).outcomes;
+  }
+  return {
+    getSnapshot: () => snapshot,
+    subscribe: (listener) => {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
+    },
+    setResponse: (responseIdentifier, value) => {
+      if (snapshot.submitted) {
+        return;
+      }
+      const responses = { ...snapshot.responses, [responseIdentifier]: value };
+      emit({
+        ...snapshot,
+        responses,
+        responseViolations: violationsOf(responses)
+      });
+    },
+    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, responseViolations: violationsOf(collected) };
+      }
+      if (options?.validateResponses && snapshot.responseViolations.length > 0) {
+        emit(snapshot);
+        return snapshot.scores;
+      }
+      const scores = computeScores(snapshot.responses);
+      const durationSeconds = activeSeconds();
+      const priorOutcomes = options?.adaptive && snapshot.attemptCount > 0 ? snapshot.outcomes : undefined;
+      const rpOutcomes = computeOutcomes(snapshot.responses, durationSeconds, priorOutcomes);
+      const outcomes = options?.responseProcessing ? rpOutcomes : { ...maintainedOutcomes(), ...rpOutcomes };
+      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,
+        durationSeconds
+      });
+      return scores;
+    },
+    suspend: () => {
+      if (runningSinceMs !== null) {
+        activeMs += now() - runningSinceMs;
+        runningSinceMs = null;
+      }
+    },
+    resume: () => {
+      runningSinceMs ??= now();
+    },
+    reset: () => {
+      activeMs = 0;
+      runningSinceMs = now();
+      emit({
+        responses: { ...initialResponses },
+        submitted: false,
+        scores: [],
+        outcomes: maintainedOutcomes(),
+        templateValues: snapshot.templateValues,
+        attemptCount: 0,
+        durationSeconds: null,
+        responseViolations: violationsOf(initialResponses),
+        correctResponses
+      });
+    }
+  };
+}
+// src/pnp.ts
+var pnpFeatureFields = {
+  "linguistic-guidance": "linguisticGuidance",
+  "keyword-emphasis": "keywordEmphasis",
+  "keyword-translation": "keywordTranslation",
+  "simplified-language-portions": "simplifiedLanguagePortions",
+  "simplified-graphics": "simplifiedGraphics",
+  "item-translation": "itemTranslation",
+  "sign-language": "signLanguage",
+  encouragement: "encouragement",
+  "additional-testing-time": "additionalTestingTime",
+  "line-reader": "lineReader",
+  "invert-display-polarity": "invertDisplayPolarity",
+  magnification: "magnification",
+  spoken: "spoken",
+  tactile: "tactile",
+  braille: "braille",
+  "answer-masking": "answerMasking",
+  "keyboard-directions": "keyboardDirections",
+  "additional-directions": "additionalDirections",
+  "long-description": "longDescription",
+  captions: "captions",
+  transcript: "transcript",
+  "alternative-text": "alternativeText",
+  "audio-description": "audioDescription",
+  "high-contrast": "highContrast",
+  "input-requirements": "inputRequirements",
+  "language-of-interface": "languageOfInterface",
+  "layout-single-column": "layoutSingleColumn",
+  "text-appearance": "textAppearance",
+  "calculator-on-screen": "calculatorOnScreen",
+  "dictionary-on-screen": "dictionaryOnScreen",
+  "glossary-on-screen": "glossaryOnScreen",
+  "thesaurus-on-screen": "thesaurusOnScreen",
+  "homophone-checker-on-screen": "homophoneCheckerOnScreen",
+  "note-taking-on-screen": "noteTakingOnScreen",
+  "visual-organizer-on-screen": "visualOrganizerOnScreen",
+  "outliner-on-screen": "outlinerOnScreen",
+  "peer-interaction-on-screen": "peerInteractionOnScreen",
+  "spell-checker-on-screen": "spellCheckerOnScreen"
+};
+function resolvePnpActivation(pnp) {
+  const prohibited = new Set(pnp?.prohibitSet?.features ?? []);
+  const active = new Set;
+  const optional = new Set;
+  if (!pnp) {
+    return { active, optional, prohibited };
+  }
+  const optedIn = new Set(pnp.activateAsOptionSet?.features ?? []);
+  for (const feature of pnp.activateAtInitializationSet?.features ?? []) {
+    active.add(feature);
+  }
+  for (const [feature, field] of Object.entries(pnpFeatureFields)) {
+    if (pnp[field] === undefined || active.has(feature) || optedIn.has(feature)) {
+      continue;
+    }
+    active.add(feature);
+  }
+  for (const feature of optedIn) {
+    if (!active.has(feature)) {
+      optional.add(feature);
+    }
+  }
+  for (const feature of prohibited) {
+    active.delete(feature);
+    optional.delete(feature);
+  }
+  return { active, optional, prohibited };
+}
+function languagesMatch(left, right) {
+  const a3 = left.toLowerCase();
+  const b2 = right.toLowerCase();
+  return a3 === b2 || a3.split("-")[0] === b2.split("-")[0];
+}
+function camelCase(name) {
+  return name.replace(/-([a-z])/gu, (_2, letter) => letter.toUpperCase());
+}
+function pnpFeaturePreference(pnp, feature) {
+  const field = pnpFeatureFields[feature];
+  if (!pnp || !field) {
+    return;
+  }
+  const value = pnp[field];
+  const first = Array.isArray(value) ? value[0] : value;
+  return typeof first === "object" && first !== null ? first : undefined;
+}
+function entryMatches(entry, preference) {
+  if (entry.xmlLang !== undefined) {
+    const preferred = preference?.["xmlLang"];
+    if (typeof preferred !== "string" || !languagesMatch(entry.xmlLang, preferred)) {
+      return false;
+    }
+  }
+  for (const [name, value] of Object.entries(entry.dataAttributes ?? {})) {
+    const preferred = preference?.[camelCase(name)];
+    const comparable = typeof preferred === "string" || typeof preferred === "number" || typeof preferred === "boolean" ? `${preferred}` : undefined;
+    if (comparable === undefined || comparable !== value) {
+      return false;
+    }
+  }
+  return true;
+}
+function resolveCard(card, pnp) {
+  if (!card.cardEntries) {
+    const cardLang = card.xmlLang ?? card.htmlContent?.xmlLang;
+    return {
+      support: card.support,
+      ...cardLang !== undefined ? { xmlLang: cardLang } : {},
+      ...card.htmlContent?.content ? { content: card.htmlContent.content } : {},
+      ...card.fileHrefs ? { fileHrefs: card.fileHrefs } : {}
+    };
+  }
+  const preference = pnpFeaturePreference(pnp, card.support);
+  const entry = card.cardEntries.find((candidate) => entryMatches(candidate, preference)) ?? card.cardEntries.find((candidate) => candidate.default === true);
+  if (!entry) {
+    return;
+  }
+  const xmlLang = entry.xmlLang ?? entry.htmlContent?.xmlLang ?? card.xmlLang;
+  return {
+    support: card.support,
+    ...xmlLang !== undefined ? { xmlLang } : {},
+    ...entry.htmlContent?.content ? { content: entry.htmlContent.content } : {},
+    ...entry.fileHrefs ? { fileHrefs: entry.fileHrefs } : {}
+  };
+}
+function resolveCatalogSupports(options) {
+  const activation = resolvePnpActivation(options.pnp);
+  const effective = new Set(activation.active);
+  for (const support of options.activeSupports ?? []) {
+    if (!activation.prohibited.has(support)) {
+      effective.add(support);
+    }
+  }
+  const byCatalogId = new Map;
+  for (const catalog of options.catalogs ?? []) {
+    const resolved = [];
+    for (const card of catalog.cards) {
+      if (!effective.has(card.support)) {
+        continue;
+      }
+      const support = resolveCard(card, options.pnp);
+      if (support) {
+        resolved.push(support);
+      }
+    }
+    byCatalogId.set(catalog.id, resolved);
+  }
+  return { activation, byCatalogId };
+}
+
+// src/test/controller.ts
+var supportedOutcomeRuleKinds = new Set([
+  "outcomeCondition",
+  "setOutcomeValue",
+  "lookupOutcomeValue",
+  "outcomeProcessingFragment",
+  "exitTest"
+]);
+var testExpressionKinds = new Set([
+  ...deterministicExpressionKinds,
+  "testVariables",
+  "outcomeMinimum",
+  "outcomeMaximum",
+  "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((_2, index) => index);
+  for (let i3 = indices.length - 1;i3 > 0; i3 -= 1) {
+    const j2 = Math.floor(random() * (i3 + 1));
+    [indices[i3], indices[j2]] = [indices[j2], indices[i3]];
+  }
+  return indices.slice(0, Math.min(count, indices.length)).sort((a3, b2) => a3 - b2).map((index) => pool[index]);
+}
+function applySelection(children, selection, random) {
+  const required = children.filter((child) => child.required === true);
+  const needed = Math.max(0, selection.select - required.length);
+  if (selection.withReplacement === true) {
+    const counts = children.map((child) => child.required === true ? 1 : 0);
+    for (let draw = 0;draw < needed; draw += 1) {
+      const index = Math.floor(random() * children.length);
+      counts[index] = (counts[index] ?? 0) + 1;
+    }
+    return children.flatMap((child, index) => Array.from({ length: counts[index] ?? 0 }, () => child));
+  }
+  const optional = children.filter((child) => child.required !== true);
+  const picked = new Set([...required, ...seededPick(optional, needed, random)]);
+  return children.filter((child) => picked.has(child));
+}
+function applyOrdering(units, random) {
+  const result = units.map((unit) => unit.child.fixed === true ? unit : null);
+  const movable = units.filter((unit) => unit.child.fixed !== true);
+  const shuffled = seededPick(movable, movable.length, random);
+  for (let i3 = shuffled.length - 1;i3 > 0; i3 -= 1) {
+    const j2 = Math.floor(random() * (i3 + 1));
+    [shuffled[i3], shuffled[j2]] = [shuffled[j2], shuffled[i3]];
+  }
+  let cursor = 0;
+  return result.map((slot) => slot ?? shuffled[cursor++]);
+}
+function mixedUnits(children, random, sections) {
+  return children.flatMap((child) => {
+    if (child.kind !== "assessmentSection" || child.visible !== false || child.keepTogether !== false) {
+      return [{ child, via: [] }];
+    }
+    sections[child.identifier] = {
+      identifier: child.identifier,
+      ...child.timeLimits ? { timeLimits: child.timeLimits } : {}
+    };
+    const inner = child.selection ? applySelection(child.children, child.selection, random) : child.children;
+    return mixedUnits(inner, random, sections).map((unit) => ({ child: unit.child, via: [child, ...unit.via] }));
+  });
+}
+function resolveSection(section, partIdentifier, sectionPath, inheritedPreConditions, inheritedControl, random, sections) {
+  const path = [...sectionPath, section.identifier];
+  sections[section.identifier] = {
+    identifier: section.identifier,
+    ...section.timeLimits ? { timeLimits: section.timeLimits } : {}
+  };
+  const preConditions = [...inheritedPreConditions, ...section.preConditions ?? []];
+  const control = { ...inheritedControl, ...definedControl(section.itemSessionControl) };
+  let children = section.children;
+  if (section.selection) {
+    children = applySelection(children, section.selection, random);
+  }
+  let units = children.map((child) => ({ child, via: [] }));
+  if (section.ordering?.shuffle) {
+    units = applyOrdering(mixedUnits(children, random, sections), random);
+  }
+  const items = [];
+  for (const { child, via } of units) {
+    const viaPath = [...path, ...via.map((entry) => entry.identifier)];
+    const viaPreConditions = [...preConditions, ...via.flatMap((entry) => entry.preConditions ?? [])];
+    const viaControl = via.reduce((merged, entry) => ({ ...merged, ...definedControl(entry.itemSessionControl) }), control);
+    if (child.kind === "assessmentSection") {
+      items.push(...resolveSection(child, partIdentifier, viaPath, viaPreConditions, viaControl, random, sections));
+    } else {
+      items.push({
+        key: child.identifier,
+        ref: child,
+        partIdentifier,
+        sectionPath: viaPath,
+        preConditions: [...viaPreConditions, ...child.preConditions ?? []],
+        sessionControl: { ...specSessionControlDefaults, ...viaControl, ...definedControl(child.itemSessionControl) },
+        ...child.timeLimits ? { timeLimits: child.timeLimits } : {}
+      });
+    }
+  }
+  return items;
+}
+function resolvePlan(view, seed) {
+  const random = mulberry32(seed);
+  const sections = {};
+  const 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, sections))
+  }));
+  const totals = new Map;
+  for (const part of parts) {
+    for (const item of part.items) {
+      totals.set(item.ref.identifier, (totals.get(item.ref.identifier) ?? 0) + 1);
+    }
+  }
+  const ordinals = new Map;
+  const keyedParts = parts.map((part) => ({
+    ...part,
+    items: part.items.map((item) => {
+      if ((totals.get(item.ref.identifier) ?? 0) < 2) {
+        return item;
+      }
+      const instance = (ordinals.get(item.ref.identifier) ?? 0) + 1;
+      ordinals.set(item.ref.identifier, instance);
+      return { ...item, key: `${item.ref.identifier}.${instance}`, instance };
+    })
+  }));
+  return {
+    ...view.timeLimits ? { timeLimits: view.timeLimits } : {},
+    parts: keyedParts,
+    sections
+  };
+}
+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;
+  const instancesByRef = new Map;
+  plan.parts.forEach((part, partIndex) => {
+    for (const item of part.items) {
+      partIndexByItemKey.set(item.key, partIndex);
+      itemsByKey.set(item.key, item);
+      const siblings = instancesByRef.get(item.ref.identifier);
+      if (siblings) {
+        siblings.push(item);
+      } else {
+        instancesByRef.set(item.ref.identifier, [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 weightOf(item, weightIdentifier) {
+    if (weightIdentifier === undefined) {
+      return 1;
+    }
+    return item.ref.weights?.find((entry) => entry.identifier === weightIdentifier)?.value ?? 1;
+  }
+  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));
+  }
+  const now = options.now ?? Date.now;
+  function touch(state) {
+    if (state.status !== "in-progress") {
+      return state;
+    }
+    const nowMs = now();
+    const timing = state.timing ?? {
+      lastTransitionAtMs: nowMs,
+      testSeconds: 0,
+      partSeconds: {},
+      sectionSeconds: {},
+      itemSeconds: {}
+    };
+    const elapsed = Math.max(0, nowMs - timing.lastTransitionAtMs) / 1000;
+    const bump = (record, key) => ({
+      ...record,
+      [key]: (record[key] ?? 0) + elapsed
+    });
+    const item = state.currentItemKey === null ? undefined : itemsByKey.get(state.currentItemKey);
+    return {
+      ...state,
+      timing: {
+        lastTransitionAtMs: nowMs,
+        testSeconds: timing.testSeconds + elapsed,
+        partSeconds: item ? bump(timing.partSeconds, item.partIdentifier) : timing.partSeconds,
+        sectionSeconds: item ? item.sectionPath.reduce((record, identifier) => bump(record, identifier), timing.sectionSeconds) : timing.sectionSeconds,
+        itemSeconds: item ? bump(timing.itemSeconds, item.key) : timing.itemSeconds
+      }
+    };
+  }
+  function secondsOf(state, scope) {
+    const timing = state.timing;
+    if (!timing) {
+      return 0;
+    }
+    switch (scope.kind) {
+      case "test":
+        return timing.testSeconds;
+      case "part":
+        return timing.partSeconds[scope.identifier] ?? 0;
+      case "section":
+        return timing.sectionSeconds[scope.identifier] ?? 0;
+      case "item":
+        return timing.itemSeconds[scope.key] ?? 0;
+    }
+  }
+  function timeLimitsOf(scope) {
+    switch (scope.kind) {
+      case "test":
+        return plan.timeLimits;
+      case "part":
+        return plan.parts.find((part) => part.identifier === scope.identifier)?.timeLimits;
+      case "section":
+        return plan.sections[scope.identifier]?.timeLimits;
+      case "item":
+        return itemsByKey.get(scope.key)?.timeLimits;
+    }
+  }
+  const additionalTestingTime = resolvePnpActivation(options.pnp).active.has("additional-testing-time") ? options.pnp?.additionalTestingTime : undefined;
+  function effectiveMaxTime(scope) {
+    if (additionalTestingTime?.unlimited === true) {
+      return;
+    }
+    const declared = timeLimitsOf(scope)?.maxTime;
+    if (declared === undefined) {
+      return;
+    }
+    if (additionalTestingTime?.timeMultiplier !== undefined) {
+      return declared * additionalTestingTime.timeMultiplier;
+    }
+    if (additionalTestingTime?.fixedMinutes !== undefined && scope.kind === "test") {
+      return declared + additionalTestingTime.fixedMinutes * 60;
+    }
+    return declared;
+  }
+  function scopeExpired(state, scope) {
+    const maxTime = effectiveMaxTime(scope);
+    return maxTime !== undefined && secondsOf(state, scope) > maxTime;
+  }
+  function enclosingScopes(item) {
+    return [
+      { kind: "item", key: item.key },
+      ...[...item.sectionPath].reverse().map((identifier) => ({ kind: "section", identifier })),
+      { kind: "part", identifier: item.partIdentifier },
+      { kind: "test" }
+    ];
+  }
+  function navigableInTime(state, item) {
+    return !enclosingScopes(item).some((scope) => scopeExpired(state, scope));
+  }
+  function minTimeBlocked(state, from, to) {
+    const itemMin = from.timeLimits?.minTime;
+    if (itemMin !== undefined && secondsOf(state, { kind: "item", key: from.key }) < itemMin) {
+      return true;
+    }
+    const destinationSections = new Set(to?.sectionPath ?? []);
+    return from.sectionPath.some((identifier) => {
+      if (destinationSections.has(identifier)) {
+        return false;
+      }
+      const minTime = plan.sections[identifier]?.timeLimits?.minTime;
+      return minTime !== undefined && secondsOf(state, { kind: "section", identifier }) < minTime;
+    });
+  }
+  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;
+  }
+  const durationValue = (seconds) => rpValue("single", [seconds], "duration");
+  function makeEnv(state, outcomes) {
+    return {
+      lookupVariable: (identifier) => {
+        if (identifier === "duration") {
+          return state.timing === undefined ? null : durationValue(state.timing.testSeconds);
+        }
+        const dot = identifier.indexOf(".");
+        if (dot !== -1) {
+          let itemKey = identifier.slice(0, dot);
+          let variableName = identifier.slice(dot + 1);
+          const secondDot = identifier.indexOf(".", dot + 1);
+          if (secondDot !== -1 && itemsByKey.has(identifier.slice(0, secondDot))) {
+            itemKey = identifier.slice(0, secondDot);
+            variableName = identifier.slice(secondDot + 1);
+          }
+          const instances = instancesByRef.get(itemKey);
+          if (instances !== undefined && instances.length > 1) {
+            const partIndex = partIndexByItemKey.get(instances[0].key);
+            if (partIndex === undefined || plan.parts[partIndex].submissionMode !== "simultaneous") {
+              return null;
+            }
+            for (let index = instances.length - 1;index >= 0; index -= 1) {
+              const instanceKey = instances[index].key;
+              if (variableName === "duration") {
+                const seconds = state.itemDurationSeconds?.[instanceKey];
+                if (seconds !== undefined) {
+                  return durationValue(seconds);
+                }
+              } else if (state.itemOutcomes[instanceKey] !== undefined) {
+                return liftFlat(state.itemOutcomes[instanceKey]?.[variableName] ?? null);
+              }
+            }
+            return null;
+          }
+          if (variableName === "duration") {
+            if (itemsByKey.has(itemKey)) {
+              const seconds = state.itemDurationSeconds?.[itemKey];
+              return seconds === undefined ? null : durationValue(seconds);
+            }
+            const partSeconds = state.timing?.partSeconds[itemKey];
+            if (plan.parts.some((part) => part.identifier === itemKey)) {
+              return partSeconds === undefined ? null : durationValue(partSeconds);
+            }
+            if (plan.sections[itemKey]) {
+              const seconds = state.timing?.sectionSeconds[itemKey];
+              return seconds === undefined ? null : durationValue(seconds);
+            }
+            return null;
+          }
+          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)) {
+            baseType = "float";
+            members.push(...lifted.values.map((entry) => Number(entry) * weightOf(item, weightIdentifier)));
+            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));
+          case "outcomeMinimum":
+          case "outcomeMaximum": {
+            const bound = expression.kind === "outcomeMaximum" ? "normalMaximum" : "normalMinimum";
+            const members = [];
+            for (const item of subset) {
+              const declared = options.itemOutcomeDeclarations?.[item.ref.identifier]?.find((entry) => entry.identifier === expression.outcomeIdentifier)?.[bound];
+              if (declared === undefined) {
+                if (expression.kind === "outcomeMaximum") {
+                  return null;
+                }
+                continue;
+              }
+              members.push(declared * weightOf(item, expression.weightIdentifier));
+            }
+            return members.length === 0 ? null : rpValue("multiple", members, "float");
+          }
+          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.kind === "outcomeProcessingFragment") {
+          executeRules(rule.rules ?? []);
+          continue;
+        }
+        if (rule.kind === "lookupOutcomeValue") {
+          if (rule.identifier !== undefined && rule.expression !== undefined) {
+            const declaration = (view.outcomeDeclarations ?? []).find((entry) => entry.identifier === rule.identifier);
+            if (!hasLookupTable(declaration)) {
+              throw new RpUnsupportedError("lookupOutcomeValue");
+            }
+            outcomes.set(rule.identifier, lookupTableValue(declaration, 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 p2 = partIndex;p2 < plan.parts.length; p2 += 1) {
+      const items = plan.parts[p2].items;
+      for (let i3 = p2 === partIndex ? itemIndex : 0;i3 < items.length; i3 += 1) {
+        const item = items[i3];
+        if (preConditionsPass(item, state) && navigableInTime(state, item)) {
+          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 withRecordedAttempt(state, itemKey, result, atMs) {
+    const entry = {
+      atMs,
+      outcomes: result.outcomes,
+      ...result.responses !== undefined ? { responses: result.responses } : {},
+      ...result.durationSeconds !== undefined ? { durationSeconds: result.durationSeconds } : {}
+    };
+    return {
+      ...state,
+      attemptHistory: {
+        ...state.attemptHistory ?? {},
+        [itemKey]: [...state.attemptHistory?.[itemKey] ?? [], entry]
+      }
+    };
+  }
+  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 itemDurations = { ...state.itemDurationSeconds ?? {} };
+    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];
+      if (result.durationSeconds !== undefined) {
+        itemDurations[key] = result.durationSeconds;
+      }
+      flagged = withRecordedAttempt(applyResultFlags(flagged, key, result), key, result, result.submittedAtMs ?? now());
+    }
+    return {
+      ...flagged,
+      itemOutcomes,
+      attemptCounts,
+      itemDurationSeconds: itemDurations,
+      pendingItemResults: remaining
+    };
+  }
+  function ended(state) {
+    const flushed = flushPending(state, null);
+    return { ...flushed, status: "ended", currentItemKey: null, testOutcomes: runOutcomeProcessing(flushed) };
+  }
+  function evaluateTemplateDefaults(state, item) {
+    const defaults = item.ref.templateDefaults;
+    if (!defaults || defaults.length === 0) {
+      return;
+    }
+    const env = makeEnv(state);
+    const values = {};
+    for (const entry of defaults) {
+      try {
+        values[entry.templateIdentifier] = toOutcomeValue(evaluateExpression(entry.expression, env));
+      } catch (error) {
+        if (!(error instanceof RpUnsupportedError)) {
+          throw error;
+        }
+      }
+    }
+    return values;
+  }
+  function withTemplateDefaults(state, items) {
+    let merged = state.templateDefaultValues ?? {};
+    let changed = false;
+    for (const item of items) {
+      if (merged[item.key] !== undefined) {
+        continue;
+      }
+      const values = evaluateTemplateDefaults(state, item);
+      if (values) {
+        merged = { ...merged, [item.key]: values };
+        changed = true;
+      }
+    }
+    return changed ? { ...state, templateDefaultValues: merged } : state;
+  }
+  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) };
+      }
+    }
+    const part = toPart === undefined ? undefined : plan.parts[toPart];
+    if (part) {
+      next = withTemplateDefaults(next, part.navigationMode === "nonlinear" ? part.items : [item]);
+    }
+    return markPresented({ ...next, currentItemKey: item.key }, item.key);
+  }
+  function nextState(state) {
+    if (state.status !== "in-progress" || 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;
+    }
+    if (part.navigationMode === "linear" && minTimeBlocked(state, currentItem, firstNavigable(state, current.partIndex, current.itemIndex + 1))) {
+      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) ?? (instancesByRef.get(branchRule.target) ?? []).map((instance) => positionOf(instance.key)).find((position) => position !== null && position.partIndex === current.partIndex && position.itemIndex > current.itemIndex) ?? null;
+      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) && navigableInTime(state, item));
+      if (blocked) {
+        return state;
+      }
+    }
+    return moveToItem(state, destination);
+  }
+  function reviewBarred(state, item) {
+    return item.sessionControl.allowReview === false && remainingAttempts(state, item.key) <= 0;
+  }
+  function reviewable(state, itemKey) {
+    const item = itemsByKey.get(itemKey);
+    return state.status === "ended" && item !== undefined && item.sessionControl.allowReview && (state.presentedItems ?? []).includes(itemKey);
+  }
+  function commentable(state, itemKey) {
+    return state.status === "in-progress" && itemsByKey.get(itemKey)?.sessionControl.allowComment === true;
+  }
+  function submitBody(state, itemKey, result) {
+    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, submittedAtMs: now() } },
+        attemptedItems: state.attemptedItems.includes(itemKey) ? state.attemptedItems : [...state.attemptedItems, itemKey]
+      };
+    }
+    if (result.valid === false && itemsByKey.get(itemKey)?.sessionControl.validateResponses === true) {
+      return state;
+    }
+    if (result.adaptive !== true && remainingAttempts(state, itemKey) <= 0) {
+      return state;
+    }
+    const next = {
+      ...withRecordedAttempt(applyResultFlags(state, itemKey, result), itemKey, result, now()),
+      itemOutcomes: { ...state.itemOutcomes, [itemKey]: result.outcomes },
+      attemptedItems: state.attemptedItems.includes(itemKey) ? state.attemptedItems : [...state.attemptedItems, itemKey],
+      attemptCounts: { ...state.attemptCounts ?? {}, [itemKey]: attemptsOf(state, itemKey) + 1 },
+      ...result.durationSeconds !== undefined ? { itemDurationSeconds: { ...state.itemDurationSeconds ?? {}, [itemKey]: result.durationSeconds } } : {}
+    };
+    return { ...next, testOutcomes: runOutcomeProcessing(next) };
+  }
+  function applyExpiries(state) {
+    if (state.status !== "in-progress") {
+      return state;
+    }
+    if (scopeExpired(state, { kind: "test" })) {
+      return ended(state);
+    }
+    const currentKey = state.currentItemKey;
+    const item = currentKey === null ? undefined : itemsByKey.get(currentKey);
+    if (!item || navigableInTime(state, item)) {
+      return state;
+    }
+    const position = positionOf(item.key);
+    return position === null ? ended(state) : moveToItem(state, firstNavigable(state, position.partIndex, position.itemIndex + 1));
+  }
+  function withTransition(state, op) {
+    if (state.status !== "in-progress") {
+      return state;
+    }
+    const touched = touch(state);
+    const settled = applyExpiries(touched);
+    if (settled !== touched) {
+      return settled;
+    }
+    const result = op(settled);
+    return result === settled ? state : result;
+  }
+  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.kind === "lookupOutcomeValue") {
+        const declaration = (view.outcomeDeclarations ?? []).find((entry) => entry.identifier === rule.identifier);
+        if (!hasLookupTable(declaration)) {
+          report("lookupOutcomeValue");
+        }
+      }
+      if (rule.expression) {
+        collectExpressionIssues(rule.expression, testExpressionKinds, report);
+      }
+      if (rule.rules) {
+        walkOutcomeRules(rule.rules);
+      }
+      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);
+    }
+    for (const entry of item.ref.templateDefaults ?? []) {
+      collectExpressionIssues(entry.expression, testExpressionKinds, report);
+    }
+  }
+  return {
+    test: view,
+    plan,
+    issues,
+    start: () => {
+      const initial = {
+        status: "in-progress",
+        currentItemKey: null,
+        itemOutcomes: {},
+        attemptedItems: [],
+        attemptCounts: {},
+        presentedItems: [],
+        respondedItems: [],
+        correctItems: [],
+        incorrectItems: [],
+        pendingItemResults: {},
+        testOutcomes: {},
+        timing: {
+          lastTransitionAtMs: now(),
+          testSeconds: 0,
+          partSeconds: {},
+          sectionSeconds: {},
+          itemSeconds: {}
+        }
+      };
+      const opened = { ...initial, testOutcomes: runOutcomeProcessing(initial) };
+      return moveToItem(opened, firstNavigable(opened, 0, 0));
+    },
+    currentItem: (state) => state.currentItemKey === null ? null : allItems.find((item) => item.key === state.currentItemKey) ?? null,
+    canMoveTo: (state, itemKey) => {
+      if (state.status !== "in-progress" || 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;
+      }
+      const item = plan.parts[target.partIndex].items[target.itemIndex];
+      return preConditionsPass(item, state) && navigableInTime(state, item) && !reviewBarred(state, item);
+    },
+    moveTo: (state, itemKey) => withTransition(state, (settled) => {
+      const current = positionOf(settled.currentItemKey ?? "");
+      const target = positionOf(itemKey);
+      const item = itemsByKey.get(itemKey);
+      if (!current || !target || !item || target.partIndex !== current.partIndex || plan.parts[current.partIndex].navigationMode !== "nonlinear" || !navigableInTime(settled, item) || reviewBarred(settled, item)) {
+        return settled;
+      }
+      return markPresented({ ...settled, currentItemKey: itemKey }, itemKey);
+    }),
+    canNext: (state) => nextState(state) !== state,
+    next: (state) => withTransition(state, nextState),
+    remainingAttempts,
+    canSubmitItem: (state, itemKey) => {
+      if (state.status !== "in-progress" || remainingAttempts(state, itemKey) <= 0) {
+        return false;
+      }
+      const item = itemsByKey.get(itemKey);
+      return item !== undefined && enclosingScopes(item).every((scope) => !scopeExpired(state, scope) || timeLimitsOf(scope)?.allowLateSubmission === true);
+    },
+    submitItem: (state, itemKey, result) => {
+      const item = itemsByKey.get(itemKey);
+      if (state.status !== "in-progress" || !item) {
+        return state;
+      }
+      const touched = touch(state);
+      const barring = enclosingScopes(item).find((scope) => scopeExpired(touched, scope) && timeLimitsOf(scope)?.allowLateSubmission !== true);
+      if (barring) {
+        return applyExpiries({
+          ...touched,
+          rejectedSubmissions: [
+            ...touched.rejectedSubmissions ?? [],
+            { itemKey, scope: barring, atTestSeconds: touched.timing?.testSeconds ?? 0 }
+          ]
+        });
+      }
+      const accepted = submitBody(touched, itemKey, result);
+      return accepted === touched ? state : applyExpiries(accepted);
+    },
+    end: (state) => state.status === "ended" ? state : ended(touch(state)),
+    tick: (state) => state.status !== "in-progress" ? state : applyExpiries(touch(state)),
+    suspend: (state) => {
+      if (state.status !== "in-progress") {
+        return state;
+      }
+      const settled = applyExpiries(touch(state));
+      return settled.status === "in-progress" ? { ...settled, status: "suspended" } : settled;
+    },
+    resume: (state) => state.status !== "suspended" ? state : {
+      ...state,
+      status: "in-progress",
+      ...state.timing ? { timing: { ...state.timing, lastTransitionAtMs: now() } } : {}
+    },
+    canReview: reviewable,
+    review: (state, itemKey) => reviewable(state, itemKey) ? { ...state, currentItemKey: itemKey } : state,
+    canComment: commentable,
+    setItemComment: (state, itemKey, comment) => commentable(state, itemKey) ? { ...state, itemComments: { ...state.itemComments ?? {}, [itemKey]: comment } } : 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/results.ts
+function iso(ms) {
+  return new Date(ms).toISOString();
+}
+function pnpSupports(pnp) {
+  if (!pnp) {
+    return [];
+  }
+  const activation = resolvePnpActivation(pnp);
+  const names = [...new Set([...activation.active, ...activation.optional, ...activation.prohibited])].sort();
+  return names.map((name) => {
+    if (activation.prohibited.has(name)) {
+      return { name, assignment: "prohibited" };
+    }
+    const preference = pnpFeaturePreference(pnp, name);
+    const xmlLang = typeof preference?.["xmlLang"] === "string" ? preference["xmlLang"] : undefined;
+    let value;
+    if (name === "additional-testing-time") {
+      const time = pnp.additionalTestingTime;
+      value = time?.unlimited === true ? "unlimited" : time?.timeMultiplier !== undefined ? String(time.timeMultiplier) : time?.fixedMinutes !== undefined ? String(time.fixedMinutes) : undefined;
+    }
+    return {
+      name,
+      assignment: "assigned",
+      ...value !== undefined ? { value } : {},
+      ...xmlLang !== undefined ? { xmlLang } : {}
+    };
+  });
+}
+function valueViews(value) {
+  if (value === null || value === undefined || value === "") {
+    return [];
+  }
+  if (Array.isArray(value)) {
+    return value.filter((member) => member !== null && member !== "").map((member) => ({ value: String(member) }));
+  }
+  if (typeof value === "object") {
+    return Object.entries(value).filter(([, member]) => member !== null && member !== "").map(([fieldIdentifier, member]) => ({ fieldIdentifier, value: String(member) }));
+  }
+  return [{ value: String(value) }];
+}
+function inferBaseType2(value, identifier) {
+  const sample = Array.isArray(value) ? value[0] : value;
+  if (typeof sample === "number") {
+    return "float";
+  }
+  if (typeof sample === "boolean") {
+    return "boolean";
+  }
+  if (identifier === "completionStatus" || identifier === "completion_status") {
+    return "identifier";
+  }
+  return typeof sample === "string" ? "string" : undefined;
+}
+function outcomeVariablesOf(outcomes, declarations) {
+  return Object.entries(outcomes).map(([identifier, value]) => {
+    const declaration = declarations?.find((entry) => entry.identifier === identifier);
+    const cardinality = declaration?.cardinality ?? (Array.isArray(value) ? "multiple" : "single");
+    const baseType = declaration?.baseType ?? inferBaseType2(value, identifier);
+    return {
+      identifier,
+      cardinality,
+      ...baseType !== undefined && cardinality !== "record" ? { baseType } : {},
+      values: valueViews(value)
+    };
+  });
+}
+function durationVariable(identifier, seconds) {
+  return {
+    identifier,
+    cardinality: "single",
+    baseType: "duration",
+    candidateResponse: { values: [{ value: String(seconds) }] }
+  };
+}
+function numAttemptsVariable(count) {
+  return {
+    identifier: "numAttempts",
+    cardinality: "single",
+    baseType: "integer",
+    candidateResponse: { values: [{ value: String(count) }] }
+  };
+}
+function responseVariablesOf(responses, details) {
+  return Object.entries(responses ?? {}).map(([identifier, value]) => {
+    const declaration = details?.responseDeclarations?.find((entry) => entry.identifier === identifier);
+    const cardinality = declaration?.cardinality ?? (Array.isArray(value) ? "multiple" : "single");
+    const baseType = declaration?.baseType;
+    const correct = details?.correctResponses?.[identifier];
+    const correctValues = correct === undefined ? [] : valueViews(correct);
+    return {
+      identifier,
+      cardinality,
+      ...baseType !== undefined && cardinality !== "record" ? { baseType } : {},
+      candidateResponse: { values: valueViews(value) },
+      ...correctValues.length > 0 ? { correctResponse: { values: correctValues } } : {}
+    };
+  });
+}
+function buildAssessmentResult(input) {
+  const { test, plan, state } = input;
+  const nowMs = input.nowMs ?? Date.now();
+  const timing = state.timing;
+  const scopeDurations = timing ? [
+    durationVariable("duration", timing.testSeconds),
+    ...plan.parts.filter((part) => timing.partSeconds[part.identifier] !== undefined).map((part) => durationVariable(`${part.identifier}.duration`, timing.partSeconds[part.identifier])),
+    ...Object.keys(plan.sections).filter((identifier) => timing.sectionSeconds[identifier] !== undefined).map((identifier) => durationVariable(`${identifier}.duration`, timing.sectionSeconds[identifier]))
+  ] : [];
+  const testOutcomes = outcomeVariablesOf(state.testOutcomes, test.outcomeDeclarations);
+  const supports = pnpSupports(input.pnp);
+  const testResult = {
+    identifier: test.identifier,
+    datestamp: iso(nowMs),
+    ...scopeDurations.length > 0 ? { responseVariables: scopeDurations } : {},
+    ...testOutcomes.length > 0 ? { outcomeVariables: testOutcomes } : {},
+    ...supports.length > 0 ? { supports } : {}
+  };
+  const itemResults = [];
+  let sequenceIndex = 0;
+  for (const part of plan.parts) {
+    for (const item of part.items) {
+      sequenceIndex += 1;
+      const details = input.itemDetails?.(item) ?? null;
+      const entries = [];
+      (state.attemptHistory?.[item.key] ?? []).forEach((attempt, index) => {
+        const outcomeVariables = outcomeVariablesOf(attempt.outcomes, details?.outcomeDeclarations);
+        entries.push({
+          identifier: item.key,
+          sequenceIndex,
+          datestamp: iso(attempt.atMs),
+          sessionStatus: "final",
+          responseVariables: [
+            numAttemptsVariable(index + 1),
+            ...attempt.durationSeconds !== undefined ? [durationVariable("duration", attempt.durationSeconds)] : [],
+            ...responseVariablesOf(attempt.responses, details)
+          ],
+          ...outcomeVariables.length > 0 ? { outcomeVariables } : {}
+        });
+      });
+      const pending = state.pendingItemResults?.[item.key];
+      if (pending) {
+        entries.push({
+          identifier: item.key,
+          sequenceIndex,
+          datestamp: iso(pending.submittedAtMs ?? nowMs),
+          sessionStatus: "pendingResponseProcessing",
+          responseVariables: [
+            numAttemptsVariable(1),
+            ...pending.durationSeconds !== undefined ? [durationVariable("duration", pending.durationSeconds)] : [],
+            ...responseVariablesOf(pending.responses, details)
+          ]
+        });
+      }
+      if (entries.length === 0) {
+        const itemSeconds = timing?.itemSeconds[item.key];
+        entries.push({
+          identifier: item.key,
+          sequenceIndex,
+          datestamp: iso(nowMs),
+          sessionStatus: "initial",
+          responseVariables: [
+            numAttemptsVariable(0),
+            ...itemSeconds !== undefined ? [durationVariable("duration", itemSeconds)] : []
+          ]
+        });
+      }
+      const comment = state.itemComments?.[item.key];
+      if (comment !== undefined) {
+        entries[entries.length - 1] = { ...entries[entries.length - 1], candidateComment: comment };
+      }
+      itemResults.push(...entries);
+    }
+  }
+  return {
+    assessmentResult: {
+      context: input.context ?? {},
+      testResult,
+      ...itemResults.length > 0 ? { itemResults } : {}
+    }
+  };
+}
+// 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 activeKeyOf(sessionState) {
+    return sessionState.status === "in-progress" ? sessionState.currentItemKey : null;
+  }
+  function emit(next) {
+    const previousActive = activeKeyOf(state);
+    state = next;
+    snapshot = buildSnapshot();
+    const nextActive = activeKeyOf(next);
+    if (previousActive !== nextActive) {
+      if (previousActive !== null) {
+        itemStores.get(previousActive)?.suspend();
+      }
+      if (nextActive !== null) {
+        itemStores.get(nextActive)?.resume();
+      }
+    }
+    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);
+    const planItem = planItemsByKey.get(itemKey);
+    if (!view || !planItem) {
+      itemStores.set(itemKey, null);
+      return null;
+    }
+    const individual = controller.plan.parts.some((part) => part.identifier === planItem.partIdentifier && part.submissionMode === "individual");
+    const store = createAttemptStore(view.responseDeclarations, {}, {
+      constraints: collectInteractionConstraints(view.itemBody.content),
+      validateResponses: planItem.sessionControl.validateResponses && individual,
+      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,
+      templateDefaultValues: state.templateDefaultValues?.[itemKey],
+      now: options.now
+    });
+    if (activeKeyOf(state) !== itemKey) {
+      store.suspend();
+    }
+    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 } : {},
+          ...attempt.durationSeconds !== null ? { durationSeconds: attempt.durationSeconds } : {},
+          valid: attempt.responseViolations.length === 0,
+          responses: attempt.responses
+        });
+        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)),
+    tick: () => emit(controller.tick(state)),
+    review: (itemKey) => emit(controller.review(state, itemKey)),
+    setItemComment: (itemKey, comment) => emit(controller.setItemComment(state, itemKey, comment)),
+    suspend: () => emit(controller.suspend(state)),
+    resume: () => emit(controller.resume(state)),
+    assessmentResult: (resultOptions) => buildAssessmentResult({
+      test: controller.test,
+      plan: controller.plan,
+      state,
+      ...resultOptions?.context !== undefined ? { context: resultOptions.context } : {},
+      nowMs: resultOptions?.nowMs ?? (options.now ?? Date.now)(),
+      ...options.pnp !== undefined ? { pnp: options.pnp } : {},
+      itemDetails: (item) => {
+        const view = itemView(item.key);
+        if (!view) {
+          return null;
+        }
+        return {
+          responseDeclarations: view.responseDeclarations,
+          ...view.outcomeDeclarations !== undefined ? { outcomeDeclarations: view.outcomeDeclarations } : {},
+          correctResponses: itemStore(item.key)?.getSnapshot().correctResponses ?? {}
+        };
+      }
+    })
+  };
+}
+// src/rp/schema.ts
+import { z as z2 } from "zod";
+var rpScalarSchema = z2.union([z2.string(), z2.number(), z2.boolean()]);
+var numberOrRef = z2.union([z2.number(), z2.string()]);
+var categoryFilter = z2.union([z2.string(), z2.array(z2.string())]);
+var cardinalitySchema = z2.enum(["single", "multiple", "ordered", "record"]);
+var rpExpressionSchema = z2.lazy(() => z2.object({
+  kind: z2.string(),
+  identifier: z2.string().optional(),
+  baseType: z2.string().optional(),
+  value: rpScalarSchema.optional(),
+  expressions: z2.array(rpExpressionSchema).optional(),
+  min: numberOrRef.optional(),
+  max: numberOrRef.optional(),
+  step: numberOrRef.optional(),
+  toleranceMode: z2.enum(["exact", "absolute", "relative"]).optional(),
+  tolerance: z2.array(numberOrRef).optional(),
+  includeLowerBound: z2.boolean().optional(),
+  includeUpperBound: z2.boolean().optional(),
+  n: numberOrRef.optional(),
+  name: z2.string().optional(),
+  roundingMode: z2.enum(["decimalPlaces", "significantFigures"]).optional(),
+  figures: numberOrRef.optional(),
+  numberRepeats: numberOrRef.optional(),
+  pattern: z2.string().optional(),
+  caseSensitive: z2.boolean().optional(),
+  substring: z2.boolean().optional(),
+  shape: z2.string().optional(),
+  coords: z2.string().optional(),
+  variableIdentifier: z2.string().optional(),
+  outcomeIdentifier: z2.string().optional(),
+  weightIdentifier: z2.string().optional(),
+  sectionIdentifier: z2.string().optional(),
+  includeCategory: categoryFilter.optional(),
+  excludeCategory: categoryFilter.optional(),
+  class: z2.string().optional(),
+  definition: z2.string().optional(),
+  fieldIdentifier: z2.string().optional()
+}));
+var matchTableSchema = z2.object({
+  defaultValue: rpScalarSchema.optional(),
+  matchTableEntries: z2.array(z2.object({ sourceValue: z2.number(), targetValue: rpScalarSchema }))
+});
+var interpolationTableSchema = z2.object({
+  defaultValue: rpScalarSchema.optional(),
+  interpolationTableEntries: z2.array(z2.object({
+    sourceValue: z2.number(),
+    targetValue: rpScalarSchema,
+    includeBoundary: z2.boolean().optional()
+  }))
+});
+var outcomeDeclarationSchema = z2.object({
+  identifier: z2.string(),
+  cardinality: cardinalitySchema,
+  baseType: z2.string().optional(),
+  defaultValue: z2.object({ values: z2.array(z2.object({ value: rpScalarSchema })) }).optional(),
+  matchTable: matchTableSchema.optional(),
+  interpolationTable: interpolationTableSchema.optional(),
+  normalMaximum: z2.number().optional(),
+  normalMinimum: z2.number().optional()
+});
+// src/test/schema.ts
+import { z as z3 } from "zod";
+var timeLimitsSchema = z3.object({
+  minTime: z3.number().nonnegative().optional(),
+  maxTime: z3.number().nonnegative().optional(),
+  allowLateSubmission: z3.boolean().optional()
+});
+var itemSessionControlSchema = z3.object({
+  maxAttempts: z3.number().int().nonnegative().optional(),
+  showFeedback: z3.boolean().optional(),
+  allowReview: z3.boolean().optional(),
+  showSolution: z3.boolean().optional(),
+  allowComment: z3.boolean().optional(),
+  allowSkipping: z3.boolean().optional(),
+  validateResponses: z3.boolean().optional()
+});
+var selectionSchema = z3.object({
+  select: z3.number().int().nonnegative(),
+  withReplacement: z3.boolean().optional()
+});
+var orderingSchema = z3.object({ shuffle: z3.boolean().optional() });
+var branchRuleSchema = z3.object({
+  target: z3.string().trim().min(1),
+  expression: rpExpressionSchema
+});
+var weightSchema = z3.object({ identifier: z3.string().trim().min(1), value: z3.number() });
+var templateDefaultSchema = z3.object({
+  templateIdentifier: z3.string().trim().min(1),
+  expression: rpExpressionSchema
+});
+var outcomeConditionBranchSchema = z3.lazy(() => z3.object({
+  expression: rpExpressionSchema,
+  rules: z3.array(outcomeRuleSchema)
+}));
+var outcomeRuleSchema = z3.lazy(() => z3.object({
+  kind: z3.string(),
+  identifier: z3.string().optional(),
+  expression: rpExpressionSchema.optional(),
+  rules: z3.array(outcomeRuleSchema).optional(),
+  outcomeIf: outcomeConditionBranchSchema.optional(),
+  outcomeElseIfs: z3.array(outcomeConditionBranchSchema).optional(),
+  outcomeElse: z3.object({ rules: z3.array(outcomeRuleSchema) }).optional()
+}));
+var outcomeProcessingSchema = z3.object({ rules: z3.array(outcomeRuleSchema) });
+var testFeedbackSchema = z3.object({
+  access: z3.enum(["atEnd", "during"]).optional(),
+  outcomeIdentifier: z3.string().trim().min(1),
+  identifier: z3.string().trim().min(1),
+  showHide: z3.enum(["show", "hide"]).optional(),
+  content: z3.array(z3.unknown()).optional()
+});
+var assessmentItemRefViewSchema = z3.object({
+  kind: z3.literal("assessmentItemRef"),
+  identifier: z3.string().trim().min(1),
+  href: z3.string().optional(),
+  categories: z3.array(z3.string()).optional(),
+  fixed: z3.boolean().optional(),
+  required: z3.boolean().optional(),
+  preConditions: z3.array(rpExpressionSchema).optional(),
+  branchRules: z3.array(branchRuleSchema).optional(),
+  itemSessionControl: itemSessionControlSchema.optional(),
+  timeLimits: timeLimitsSchema.optional(),
+  weights: z3.array(weightSchema).optional(),
+  templateDefaults: z3.array(templateDefaultSchema).optional()
+});
+var assessmentSectionFlags = {
+  title: z3.string().trim().min(1).optional(),
+  visible: z3.boolean().optional(),
+  fixed: z3.boolean().optional(),
+  required: z3.boolean().optional(),
+  keepTogether: z3.boolean().optional(),
+  selection: selectionSchema.optional(),
+  ordering: orderingSchema.optional(),
+  preConditions: z3.array(rpExpressionSchema).optional(),
+  branchRules: z3.array(branchRuleSchema).optional(),
+  itemSessionControl: itemSessionControlSchema.optional(),
+  timeLimits: timeLimitsSchema.optional()
+};
+var testPartLevel = {
+  preConditions: z3.array(rpExpressionSchema).optional(),
+  branchRules: z3.array(branchRuleSchema).optional(),
+  itemSessionControl: itemSessionControlSchema.optional(),
+  timeLimits: timeLimitsSchema.optional()
+};
+function makeAssessmentTestSchema(itemRefSchema) {
+  const assessmentSectionSchema = z3.lazy(() => z3.object({
+    kind: z3.literal("assessmentSection"),
+    identifier: z3.string().trim().min(1),
+    ...assessmentSectionFlags,
+    children: z3.array(z3.union([assessmentSectionSchema, itemRefSchema]))
+  }));
+  const testPartSchema = z3.object({
+    identifier: z3.string().trim().min(1),
+    navigationMode: z3.enum(["linear", "nonlinear"]),
+    submissionMode: z3.enum(["individual", "simultaneous"]),
+    ...testPartLevel,
+    assessmentSections: z3.array(assessmentSectionSchema)
+  });
+  const assessmentTestSchema = z3.object({
+    identifier: z3.string().trim().min(1),
+    title: z3.string().trim().min(1).optional(),
+    outcomeDeclarations: z3.array(outcomeDeclarationSchema).optional(),
+    timeLimits: timeLimitsSchema.optional(),
+    testParts: z3.array(testPartSchema),
+    outcomeProcessing: outcomeProcessingSchema.optional(),
+    testFeedbacks: z3.array(testFeedbackSchema).optional()
+  });
+  return { assessmentSectionSchema, testPartSchema, assessmentTestSchema };
+}
+var assessmentTestViewSchema = makeAssessmentTestSchema(assessmentItemRefViewSchema).assessmentTestSchema;
 export {
+  timeLimitsSchema,
+  testFeedbackSchema,
   stimulusContentFromNormalized,
+  selectionSchema,
+  scoreResponse,
+  rpScalarSchema,
+  rpExpressionSchema,
+  resolveTemplate,
   reportItemCapability,
   referenceInteractionKinds,
+  outcomeRuleSchema,
+  outcomeProcessingSchema,
+  outcomeDeclarationSchema,
+  outcomeConditionBranchSchema,
+  orderingSchema,
+  mulberry32,
+  matchTableSchema,
+  matchCorrect,
+  mapResponsePoint,
+  mapResponse,
+  makeAssessmentTestSchema,
+  itemSessionControlSchema,
+  interpolationTableSchema,
+  foldString,
+  executeTemplateProcessing,
+  executeResponseProcessing,
+  effectiveItemScore,
+  createTestController,
+  createAttemptStore,
+  collectTemplateIssues,
+  collectRpIssues,
+  cardinalitySchema,
+  branchRuleSchema,
+  assessmentTestViewSchema,
   assessmentTestViewFromNormalized,
-  assessmentItemViewFromNormalized
+  assessmentItemViewFromNormalized,
+  assessmentItemRefViewSchema,
+  applyCorrectResponseOverrides
 };