@conform-ed/qti-react 0.0.15 → 0.0.17

package/dist/index.js

@@ -38,6 +38,9 @@ var v0FlowElements = new Set([
   "rb",
   "rt",
   "rp",
+  "rtc",
+  "bdo",
+  "bdi",
   "img",
   "audio",
   "video",
@@ -64,9 +67,35 @@ var v0FlowElements = new Set([
   "tfoot",
   "tr",
   "th",
-  "td"
+  "td",
+  "a",
+  "abbr",
+  "acronym",
+  "address",
+  "article",
+  "aside",
+  "big",
+  "code",
+  "details",
+  "summary",
+  "dfn",
+  "dl",
+  "dt",
+  "dd",
+  "kbd",
+  "label",
+  "nav",
+  "pre",
+  "q",
+  "samp",
+  "small",
+  "tt",
+  "var",
+  "footer",
+  "header"
 ]);
 var v0ElementAttributes = new Map([
+  ["a", new Set(["href", "type"])],
   ["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"])],
@@ -74,7 +103,7 @@ var v0ElementAttributes = new Map([
   ["track", new Set(["src", "kind", "srclang", "label", "default"])],
   ["object", new Set(["data", "type", "width", "height"])]
 ]);
-var v0UrlAttributes = new Set(["src", "poster", "data"]);
+var v0UrlAttributes = new Set(["src", "poster", "data", "href"]);
 var v0MathRoot = "math";
 var v0GlobalAttributes = new Set(["id", "class", "lang", "xml:lang", "dir"]);
 var v0ContentModel = {
@@ -111,7 +140,8 @@ function sanitizeAttributes(model, elementName, attributes) {
     if (isUnsafeAttribute(name, value)) {
       continue;
     }
-    if (!model.globalAttributes.has(name) && !elementAllowed?.has(name)) {
+    const ariaOrData = name === "role" || name.startsWith("aria-") || name.startsWith("data-");
+    if (!ariaOrData && !model.globalAttributes.has(name) && !elementAllowed?.has(name)) {
       continue;
     }
     if (typeof value === "string") {
@@ -538,6 +568,9 @@ function convertRpRule(rule) {
       } : {}
     };
   }
+  if (kind === "responseProcessingFragment") {
+    return { kind, rules: (Array.isArray(record["rules"]) ? record["rules"] : []).map(convertRpRule) };
+  }
   return {
     kind,
     ...typeof record["identifier"] === "string" ? { identifier: record["identifier"] } : {},
@@ -580,6 +613,29 @@ function convertResponseDeclaration(declaration) {
   const areaMapEntries = asRecords(areaMapping["areaMapEntries"]).map((entry) => withNumericCoords(entry));
   return { ...declaration, areaMapping: { ...areaMapping, areaMapEntries } };
 }
+function appendCatalogViews(target, value) {
+  if (Array.isArray(value)) {
+    for (const entry of value) {
+      appendCatalogViews(target, entry);
+    }
+    return;
+  }
+  if (!isRecord(value)) {
+    return;
+  }
+  const catalogInfo = value["catalogInfo"];
+  if (isRecord(catalogInfo) && Array.isArray(catalogInfo["catalogs"])) {
+    target.push(...catalogInfo["catalogs"]);
+  }
+  appendCatalogViews(target, value["content"]);
+  appendCatalogViews(target, value["children"]);
+}
+function documentCatalogViews(root, convertedContent) {
+  const catalogs = [];
+  appendCatalogViews(catalogs, isRecord(root["catalogInfo"]) ? { catalogInfo: convertContentValue(root["catalogInfo"]) } : undefined);
+  appendCatalogViews(catalogs, convertedContent);
+  return catalogs;
+}
 function assessmentItemViewFromNormalized(document) {
   if (!isRecord(document) || !isRecord(document["assessmentItem"])) {
     return null;
@@ -588,6 +644,8 @@ function assessmentItemViewFromNormalized(document) {
   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;
+  const convertedModalFeedbacks = Array.isArray(item["modalFeedbacks"]) ? item["modalFeedbacks"].map(convertContentValue) : undefined;
+  const catalogs = documentCatalogViews(item, [content, convertedModalFeedbacks]);
   return {
     responseDeclarations: asRecords(item["responseDeclarations"]).map(convertResponseDeclaration),
     outcomeDeclarations: item["outcomeDeclarations"] ?? [],
@@ -599,10 +657,29 @@ function assessmentItemViewFromNormalized(document) {
       }
     } : {},
     ...typeof item["adaptive"] === "boolean" ? { adaptive: item["adaptive"] } : {},
-    ...Array.isArray(item["modalFeedbacks"]) ? { modalFeedbacks: item["modalFeedbacks"].map(convertContentValue) } : {},
+    ...convertedModalFeedbacks ? { modalFeedbacks: convertedModalFeedbacks } : {},
+    ...catalogs.length ? { catalogs } : {},
+    ...isRecord(item["companionMaterialsInfo"]) ? { companionMaterials: item["companionMaterialsInfo"] } : {},
+    ...Array.isArray(item["assessmentStimulusRefs"]) ? {
+      assessmentStimulusRefs: asRecords(item["assessmentStimulusRefs"]).map((ref) => ({
+        identifier: typeof ref["identifier"] === "string" ? ref["identifier"] : "",
+        href: typeof ref["href"] === "string" ? ref["href"] : "",
+        ...typeof ref["title"] === "string" ? { title: ref["title"] } : {}
+      }))
+    } : {},
     itemBody: { content }
   };
 }
+function stimulusContentFromNormalized(document) {
+  if (!isRecord(document) || !isRecord(document["assessmentStimulus"])) {
+    return null;
+  }
+  const stimulus = document["assessmentStimulus"];
+  const body = isRecord(stimulus["stimulusBody"]) ? stimulus["stimulusBody"] : {};
+  const content = Array.isArray(body["content"]) ? body["content"].map(convertContentEntry) : [];
+  const catalogs = documentCatalogViews(stimulus, content);
+  return { content, ...catalogs.length ? { catalogs } : {} };
+}
 function convertPreConditions(value) {
   return asRecords(value).map((wrapper) => convertExpression(wrapper["expression"]));
 }
@@ -628,6 +705,9 @@ function convertOutcomeRule(rule) {
       } : {}
     };
   }
+  if (kind === "outcomeProcessingFragment") {
+    return { kind, rules: (Array.isArray(record["rules"]) ? record["rules"] : []).map(convertOutcomeRule) };
+  }
   return {
     kind,
     ...typeof record["identifier"] === "string" ? { identifier: record["identifier"] } : {},
@@ -651,6 +731,12 @@ function convertItemRef(ref) {
     ...ref["preConditions"] !== undefined ? { preConditions: convertPreConditions(ref["preConditions"]) } : {},
     ...ref["branchRules"] !== undefined ? { branchRules: convertBranchRules(ref["branchRules"]) } : {},
     ...Array.isArray(ref["weights"]) ? { weights: ref["weights"] } : {},
+    ...Array.isArray(ref["templateDefaults"]) ? {
+      templateDefaults: asRecords(ref["templateDefaults"]).map((entry) => ({
+        templateIdentifier: typeof entry["templateIdentifier"] === "string" ? entry["templateIdentifier"] : "",
+        expression: convertExpression(entry["expression"])
+      }))
+    } : {},
     ...sessionControlAndTimeLimits(ref)
   };
 }
@@ -663,6 +749,7 @@ function convertSection(section) {
     ...typeof section["visible"] === "boolean" ? { visible: section["visible"] } : {},
     ...typeof section["fixed"] === "boolean" ? { fixed: section["fixed"] } : {},
     ...typeof section["required"] === "boolean" ? { required: section["required"] } : {},
+    ...typeof section["keepTogether"] === "boolean" ? { keepTogether: section["keepTogether"] } : {},
     ...isRecord(section["selection"]) ? { selection: section["selection"] } : {},
     ...isRecord(section["ordering"]) ? { ordering: section["ordering"] } : {},
     ...section["preConditions"] !== undefined ? { preConditions: convertPreConditions(section["preConditions"]) } : {},
@@ -706,6 +793,715 @@ function assessmentTestViewFromNormalized(document) {
     ...Array.isArray(testDocument["testFeedbacks"]) ? { testFeedbacks: asRecords(testDocument["testFeedbacks"]).map(convertTestFeedback) } : {}
   };
 }
+// ../../node_modules/.bun/whynot@5.0.0/node_modules/whynot/dist/whynot.esm.js
+function t(t2, s, r, i) {
+  const n = { op: s, func: r, data: i };
+  return t2.push(n), n;
+}
+function s(t2, s2) {
+  return t2;
+}
+
+class r {
+  constructor() {
+    this.program = [];
+  }
+  test(s2, r2) {
+    return t(this.program, 5, s2, r2 === undefined ? null : r2);
+  }
+  jump(s2) {
+    return t(this.program, 3, null, s2);
+  }
+  record(r2, i) {
+    return t(this.program, 4, i === undefined ? s : i, r2);
+  }
+  bad(s2 = 1) {
+    return t(this.program, 1, null, s2);
+  }
+  accept() {
+    return t(this.program, 0, null, null);
+  }
+  fail(s2) {
+    return t(this.program, 2, s2 || null, null);
+  }
+}
+
+class i {
+  constructor(t2, s2, r2) {
+    this.programLength = t2, this.maxFromByPc = s2, this.maxSurvivorFromByPc = r2;
+  }
+  static fromProgram(t2) {
+    const s2 = t2.length, r2 = [], n = [];
+    return t2.forEach((t3) => {
+      r2.push(0), n.push(0);
+    }), t2.forEach((t3, i2) => {
+      switch (t3.op) {
+        case 2:
+          if (t3.func === null)
+            return;
+          if (i2 + 1 >= s2)
+            throw new Error("Invalid program: program could run past end");
+          r2[i2 + 1] += 1;
+          break;
+        case 1:
+        case 4:
+          if (i2 + 1 >= s2)
+            throw new Error("Invalid program: program could run past end");
+          r2[i2 + 1] += 1;
+          break;
+        case 3:
+          t3.data.forEach((t4) => {
+            if (t4 < 0 || t4 >= s2)
+              throw new Error("Invalid program: program could run past end");
+            r2[t4] += 1;
+          });
+          break;
+        case 5:
+          if (i2 + 1 >= s2)
+            throw new Error("Invalid program: program could run past end");
+          n[i2 + 1] += 1;
+          break;
+        case 0:
+          n[i2] += 1;
+      }
+    }), new i(s2, r2, n);
+  }
+  static createStub(t2) {
+    const s2 = [], r2 = [];
+    for (let i2 = 0;i2 < t2; ++i2)
+      s2.push(t2), r2.push(t2);
+    return new i(t2, s2, r2);
+  }
+}
+
+class n {
+  constructor(t2) {
+    this.acceptingTraces = t2, this.success = t2.length > 0;
+  }
+}
+
+class h {
+  constructor(t2) {
+    this.t = 0, this.i = 0, this.h = new Uint16Array(t2), this.l = new Uint8Array(t2);
+  }
+  getBadness(t2) {
+    return this.l[t2];
+  }
+  add(t2, s2) {
+    this.l[t2] = s2 > 255 ? 255 : s2;
+    const r2 = function(t3, s3, r3, i2, n2) {
+      let h2 = i2, e = n2;
+      for (;h2 < e; ) {
+        const i3 = h2 + e >>> 1;
+        r3 < s3[t3[i3]] ? e = i3 : h2 = i3 + 1;
+      }
+      return h2;
+    }(this.h, this.l, s2, this.i, this.t);
+    this.h.copyWithin(r2 + 1, r2, this.t), this.h[r2] = t2, this.t += 1;
+  }
+  reschedule(t2, s2) {
+    const r2 = Math.max(this.l[t2], s2 > 255 ? 255 : s2);
+    if (this.l[t2] !== r2) {
+      const s3 = this.h.indexOf(t2, this.i);
+      if (s3 < 0 || s3 >= this.t)
+        return void (this.l[t2] = r2);
+      this.h.copyWithin(s3, s3 + 1, this.t), this.t -= 1, this.add(t2, r2);
+    }
+  }
+  getNextPc() {
+    return this.i >= this.t ? null : this.h[this.i++];
+  }
+  reset() {
+    this.t = 0, this.i = 0, this.l.fill(0);
+  }
+}
+
+class e {
+  constructor(t2) {
+    this.o = [];
+    let s2 = t2.length;
+    t2.forEach((t3) => {
+      this.o.push(t3 > 0 ? s2 : -1), s2 += t3;
+    }), this.u = new Uint16Array(s2);
+  }
+  clear() {
+    this.u.fill(0, 0, this.o.length);
+  }
+  add(t2, s2) {
+    const r2 = this.u[s2], i2 = this.o[s2];
+    this.u[s2] += 1, this.u[i2 + r2] = t2;
+  }
+  has(t2) {
+    return this.u[t2] > 0;
+  }
+  forEach(t2, s2) {
+    const r2 = this.u[t2], i2 = this.o[t2];
+    for (let t3 = i2;t3 < i2 + r2; ++t3)
+      s2(this.u[t3]);
+  }
+}
+function l(t2, s2, r2 = false) {
+  return t2 === null ? s2 : Array.isArray(t2) ? (t2.indexOf(s2) === -1 && (r2 && (t2 = t2.slice()), t2.push(s2)), t2) : t2 === s2 ? t2 : [t2, s2];
+}
+
+class c {
+  constructor(t2, s2) {
+    this.prefixes = t2, this.record = s2;
+  }
+}
+function o(t2, s2) {
+  let r2;
+  if (s2 === null) {
+    if (!Array.isArray(t2))
+      return t2;
+    r2 = t2;
+  } else
+    r2 = t2 === c.EMPTY ? [] : Array.isArray(t2) ? t2 : [t2];
+  return new c(r2, s2);
+}
+c.EMPTY = new c([], null);
+
+class u {
+  constructor(t2) {
+    this.p = [], this.v = [];
+    for (let s2 = 0;s2 < t2; ++s2)
+      this.p.push(0), this.v.push(null);
+  }
+  mergeTraces(t2, s2, r2, i2, n2, h2) {
+    let e2 = false;
+    return r2.forEach(s2, (s3) => {
+      const r3 = this.trace(s3, i2, n2, h2);
+      var c2, o2, u2;
+      o2 = r3, u2 = e2, t2 = (c2 = t2) === null ? o2 : o2 === null ? c2 : Array.isArray(o2) ? o2.reduce((t3, s4) => l(t3, s4, t3 === o2), c2) : l(c2, o2, u2), e2 = t2 === r3;
+    }), t2;
+  }
+  trace(t2, s2, r2, i2) {
+    switch (this.p[t2]) {
+      case 2:
+        return this.v[t2];
+      case 1:
+        return null;
+    }
+    this.p[t2] = 1;
+    let n2 = null;
+    const h2 = s2[t2];
+    if (h2 !== null)
+      n2 = h2;
+    else if (!r2.has(t2))
+      throw new Error("Trace without source at pc " + t2);
+    if (n2 = this.mergeTraces(n2, t2, r2, s2, r2, i2), n2 !== null) {
+      const s3 = i2[t2];
+      s3 !== null && (n2 = o(n2, s3));
+    }
+    return this.v[t2] = n2, this.p[t2] = 2, n2;
+  }
+  buildSurvivorTraces(t2, s2, r2, i2, n2) {
+    for (let h2 = 0, e2 = t2.length;h2 < e2; ++h2) {
+      if (!r2.has(h2)) {
+        s2[h2] = null;
+        continue;
+      }
+      this.v.fill(null), this.p.fill(0);
+      const e3 = this.mergeTraces(null, h2, r2, t2, i2, n2);
+      if (e3 === null)
+        throw new Error("No non-cyclic paths found to survivor " + h2);
+      s2[h2] = o(e3, null);
+    }
+    this.v.fill(null);
+  }
+}
+
+class a {
+  constructor(t2) {
+    this.g = [], this.k = [], this.m = [], this.A = new e(t2.maxFromByPc), this.T = new e(t2.maxSurvivorFromByPc), this.S = new u(t2.programLength);
+    for (let s2 = 0;s2 < t2.programLength; ++s2)
+      this.g.push(null), this.k.push(null), this.m.push(null);
+    this.k[0] = c.EMPTY;
+  }
+  reset(t2) {
+    this.A.clear(), this.T.clear(), this.g.fill(null), t2 && (this.k.fill(null), this.m.fill(null), this.k[0] = c.EMPTY);
+  }
+  record(t2, s2) {
+    this.g[t2] = s2;
+  }
+  has(t2) {
+    return this.A.has(t2) || this.k[t2] !== null;
+  }
+  add(t2, s2) {
+    this.A.add(t2, s2);
+  }
+  hasSurvivor(t2) {
+    return this.T.has(t2);
+  }
+  addSurvivor(t2, s2) {
+    this.T.add(t2, s2);
+  }
+  buildSurvivorTraces() {
+    const t2 = this.k;
+    this.S.buildSurvivorTraces(t2, this.m, this.T, this.A, this.g), this.k = this.m, this.m = t2;
+  }
+  getTraces(t2) {
+    const s2 = t2.reduce((t3, s3) => l(t3, this.k[s3]), null);
+    return s2 === null ? [] : Array.isArray(s2) ? s2 : [s2];
+  }
+}
+
+class f {
+  constructor(t2) {
+    this.I = [], this.N = new h(t2.programLength), this.M = new h(t2.programLength), this.P = new a(t2);
+  }
+  reset() {
+    this.N.reset(), this.N.add(0, 0), this.I.length = 0, this.P.reset(true);
+  }
+  getNextThreadPc() {
+    return this.N.getNextPc();
+  }
+  step(t2, s2, r2) {
+    const i2 = this.P.has(s2);
+    this.P.add(t2, s2);
+    const n2 = this.N.getBadness(t2) + r2;
+    i2 ? this.N.reschedule(s2, n2) : this.N.add(s2, n2);
+  }
+  stepToNextGeneration(t2, s2) {
+    const r2 = this.P.hasSurvivor(s2);
+    this.P.addSurvivor(t2, s2);
+    const i2 = this.N.getBadness(t2);
+    r2 ? this.M.reschedule(s2, i2) : this.M.add(s2, i2);
+  }
+  accept(t2) {
+    this.I.push(t2), this.P.addSurvivor(t2, t2);
+  }
+  fail(t2) {}
+  record(t2, s2) {
+    this.P.record(t2, s2);
+  }
+  nextGeneration() {
+    this.P.buildSurvivorTraces(), this.P.reset(false);
+    const t2 = this.N;
+    t2.reset(), this.N = this.M, this.M = t2;
+  }
+  getAcceptingTraces() {
+    return this.P.getTraces(this.I);
+  }
+}
+
+class d {
+  constructor(t2) {
+    this.U = [], this.G = t2, this.V = i.fromProgram(t2), this.U.push(new f(this.V));
+  }
+  execute(t2, s2) {
+    const r2 = this.U.pop() || new f(this.V);
+    r2.reset();
+    const i2 = t2.length;
+    let h2, e2 = -1;
+    do {
+      let n2 = r2.getNextThreadPc();
+      if (n2 === null)
+        break;
+      for (++e2, h2 = e2 >= i2 ? null : t2[e2];n2 !== null; ) {
+        const t3 = this.G[n2];
+        switch (t3.op) {
+          case 0:
+            h2 === null ? r2.accept(n2) : r2.fail(n2);
+            break;
+          case 2: {
+            const i3 = t3.func;
+            if (i3 === null || i3(s2)) {
+              r2.fail(n2);
+              break;
+            }
+            r2.step(n2, n2 + 1, 0);
+            break;
+          }
+          case 1:
+            r2.step(n2, n2 + 1, t3.data);
+            break;
+          case 5:
+            if (h2 === null) {
+              r2.fail(n2);
+              break;
+            }
+            if (!(0, t3.func)(h2, t3.data, s2)) {
+              r2.fail(n2);
+              break;
+            }
+            r2.stepToNextGeneration(n2, n2 + 1);
+            break;
+          case 3: {
+            const s3 = t3.data, i3 = s3.length;
+            if (i3 === 0) {
+              r2.fail(n2);
+              break;
+            }
+            for (let t4 = 0;t4 < i3; ++t4)
+              r2.step(n2, s3[t4], 0);
+            break;
+          }
+          case 4: {
+            const i3 = (0, t3.func)(t3.data, e2, s2);
+            i3 != null && r2.record(n2, i3), r2.step(n2, n2 + 1, 0);
+            break;
+          }
+        }
+        n2 = r2.getNextThreadPc();
+      }
+      r2.nextGeneration();
+    } while (h2 !== null);
+    const l2 = new n(r2.getAcceptingTraces());
+    return r2.reset(), this.U.push(r2), l2;
+  }
+}
+function w(t2) {
+  const s2 = new r;
+  return t2(s2), new d(s2.program);
+}
+
+// ../../node_modules/.bun/xspattern@3.1.0/node_modules/xspattern/dist/xspattern.esm.js
+function B(A) {
+  return (B2) => B2 === A;
+}
+function a2(A, B2) {
+  if (A === null || B2 === null)
+    throw new Error("unescaped hyphen may not be used as a range endpoint");
+  if (B2 < A)
+    throw new Error("character range is in the wrong order");
+  return (a3) => A <= a3 && a3 <= B2;
+}
+function n2(A) {
+  return true;
+}
+function e2() {
+  return false;
+}
+function t2(A, B2) {
+  return (a3) => A(a3) || B2(a3);
+}
+function G(A, B2) {
+  switch (B2.kind) {
+    case "predicate":
+      return void A.test(B2.value);
+    case "regexp":
+      return void r2(A, B2.value, false);
+  }
+}
+function i2(A, B2) {
+  B2.forEach((B3) => {
+    (function(A2, B4) {
+      const [a3, { min: n3, max: e3 }] = B4;
+      if (e3 !== null) {
+        for (let B5 = 0;B5 < n3; ++B5)
+          G(A2, a3);
+        for (let B5 = n3;B5 < e3; ++B5) {
+          const B6 = A2.jump([]);
+          B6.data.push(A2.program.length), G(A2, a3), B6.data.push(A2.program.length);
+        }
+      } else if (n3 > 0) {
+        for (let B6 = 0;B6 < n3 - 1; ++B6)
+          G(A2, a3);
+        const B5 = A2.program.length;
+        G(A2, a3), A2.jump([B5]).data.push(A2.program.length);
+      } else {
+        const B5 = A2.program.length, n4 = A2.jump([]);
+        n4.data.push(A2.program.length), G(A2, a3), A2.jump([B5]), n4.data.push(A2.program.length);
+      }
+    })(A, B3);
+  });
+}
+function r2(A, B2, a3) {
+  const n3 = A.program.length, e3 = A.jump([]);
+  a3 && (e3.data.push(A.program.length), A.test(() => true), A.jump([n3]));
+  const t3 = [];
+  if (B2.forEach((B3) => {
+    e3.data.push(A.program.length), i2(A, B3), t3.push(A.jump([]));
+  }), t3.forEach((B3) => {
+    B3.data.push(A.program.length);
+  }), a3) {
+    const B3 = A.program.length, a4 = A.jump([]);
+    a4.data.push(A.program.length), A.test(() => true), A.jump([B3]), a4.data.push(A.program.length);
+  }
+}
+function o2(A, B2) {
+  return { success: true, offset: A, value: B2 };
+}
+function l2(A) {
+  return o2(A, undefined);
+}
+function H(A, B2, a3 = false) {
+  return { success: false, offset: A, expected: B2, fatal: a3 };
+}
+function C(A) {
+  return (B2, a3) => {
+    const n3 = a3 + A.length;
+    return B2.slice(a3, n3) === A ? o2(n3, A) : H(a3, [A]);
+  };
+}
+function u2(A, B2) {
+  return (a3, n3) => {
+    const e3 = A(a3, n3);
+    return e3.success ? o2(e3.offset, B2(e3.value)) : e3;
+  };
+}
+function s2(A, B2, a3, n3) {
+  return (e3, t3) => {
+    const G2 = A(e3, t3);
+    return G2.success ? B2(G2.value) ? G2 : H(t3, a3, n3) : G2;
+  };
+}
+function c2(A, B2) {
+  return (a3, n3) => {
+    let e3 = null;
+    for (const t3 of A) {
+      const A2 = t3(a3, n3);
+      if (A2.success)
+        return A2;
+      if (e3 === null || A2.offset > e3.offset ? e3 = A2 : A2.offset === e3.offset && B2 === undefined && (e3.expected = e3.expected.concat(A2.expected)), A2.fatal)
+        return A2;
+    }
+    return B2 = B2 || (e3 == null ? undefined : e3.expected) || [], e3 && (e3.expected = B2), e3 || H(n3, B2);
+  };
+}
+function D(A) {
+  return (B2, a3) => {
+    const n3 = A(B2, a3);
+    return n3.success || n3.fatal ? n3 : o2(a3, null);
+  };
+}
+function m(A) {
+  return (B2, a3) => {
+    let n3 = [], e3 = a3;
+    for (;; ) {
+      const a4 = A(B2, e3);
+      if (!a4.success) {
+        if (a4.fatal)
+          return a4;
+        break;
+      }
+      if (n3.push(a4.value), a4.offset === e3)
+        break;
+      e3 = a4.offset;
+    }
+    return o2(e3, n3);
+  };
+}
+function I(A, B2, a3) {
+  return (n3, e3) => {
+    const t3 = A(n3, e3);
+    if (!t3.success)
+      return t3;
+    const G2 = B2(n3, t3.offset);
+    return G2.success ? o2(G2.offset, a3(t3.value, G2.value)) : G2;
+  };
+}
+function d2(A) {
+  return I(A, m(A), (A2, B2) => [A2].concat(B2));
+}
+function h2(A, B2) {
+  return A;
+}
+function p(A, B2) {
+  return B2;
+}
+function T(A, B2) {
+  return I(A, B2, p);
+}
+function F(A, B2) {
+  return I(A, B2, h2);
+}
+function E(A, B2, a3, n3 = false) {
+  return T(A, n3 ? f2(F(B2, a3)) : F(B2, a3));
+}
+function g(A, B2) {
+  return (a3, n3) => A(a3, n3).success ? H(n3, B2) : l2(n3);
+}
+function f2(A) {
+  return (B2, a3) => {
+    const n3 = A(B2, a3);
+    return n3.success ? n3 : H(n3.offset, n3.expected, true);
+  };
+}
+var P = (A, B2) => A.length === B2 ? l2(B2) : H(B2, ["end of input"]);
+var M = ["Lu", "Ll", "Lt", "Lm", "Lo", "Mn", "Mc", "Me", "Nd", "Nl", "No", "Pc", "Pd", "Ps", "Pe", "Pi", "Pf", "Po", "Zs", "Zl", "Zp", "Sm", "Sc", "Sk", "So", "Cc", "Cf", "Co", "Cn"];
+var J = {};
+function S(A) {
+  return A.codePointAt(0);
+}
+"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/".split("").forEach((A, B2) => {
+  J[A] = B2;
+});
+var K = (A) => A === -1 || A === -2;
+function b(A) {
+  return (B2) => !K(B2) && !A(B2);
+}
+function y(A, B2) {
+  return B2 === null ? A : (a3) => A(a3) && !B2(a3);
+}
+var Q = function(A, B2) {
+  const n3 = new Map;
+  let e3 = 0;
+  return A.forEach((A2, G2) => {
+    const i3 = B2[G2];
+    A2 !== null && A2.split("|").forEach((A3) => {
+      const B3 = n3.get(A3), G3 = a2(e3, e3 + i3 - 1);
+      n3.set(A3, B3 ? t2(B3, G3) : G3);
+    }), e3 += i3;
+  }), n3;
+}(["BasicLatin", "Latin-1Supplement", "LatinExtended-A", "LatinExtended-B", "IPAExtensions", "SpacingModifierLetters", "CombiningDiacriticalMarks", "GreekandCoptic|Greek", "Cyrillic", "CyrillicSupplement", "Armenian", "Hebrew", "Arabic", "Syriac", "ArabicSupplement", "Thaana", "NKo", "Samaritan", "Mandaic", "SyriacSupplement", "ArabicExtended-B", "ArabicExtended-A", "Devanagari", "Bengali", "Gurmukhi", "Gujarati", "Oriya", "Tamil", "Telugu", "Kannada", "Malayalam", "Sinhala", "Thai", "Lao", "Tibetan", "Myanmar", "Georgian", "HangulJamo", "Ethiopic", "EthiopicSupplement", "Cherokee", "UnifiedCanadianAboriginalSyllabics", "Ogham", "Runic", "Tagalog", "Hanunoo", "Buhid", "Tagbanwa", "Khmer", "Mongolian", "UnifiedCanadianAboriginalSyllabicsExtended", "Limbu", "TaiLe", "NewTaiLue", "KhmerSymbols", "Buginese", "TaiTham", "CombiningDiacriticalMarksExtended", "Balinese", "Sundanese", "Batak", "Lepcha", "OlChiki", "CyrillicExtended-C", "GeorgianExtended", "SundaneseSupplement", "VedicExtensions", "PhoneticExtensions", "PhoneticExtensionsSupplement", "CombiningDiacriticalMarksSupplement", "LatinExtendedAdditional", "GreekExtended", "GeneralPunctuation", "SuperscriptsandSubscripts", "CurrencySymbols", "CombiningDiacriticalMarksforSymbols|CombiningMarksforSymbols", "LetterlikeSymbols", "NumberForms", "Arrows", "MathematicalOperators", "MiscellaneousTechnical", "ControlPictures", "OpticalCharacterRecognition", "EnclosedAlphanumerics", "BoxDrawing", "BlockElements", "GeometricShapes", "MiscellaneousSymbols", "Dingbats", "MiscellaneousMathematicalSymbols-A", "SupplementalArrows-A", "BraillePatterns", "SupplementalArrows-B", "MiscellaneousMathematicalSymbols-B", "SupplementalMathematicalOperators", "MiscellaneousSymbolsandArrows", "Glagolitic", "LatinExtended-C", "Coptic", "GeorgianSupplement", "Tifinagh", "EthiopicExtended", "CyrillicExtended-A", "SupplementalPunctuation", "CJKRadicalsSupplement", "KangxiRadicals", null, "IdeographicDescriptionCharacters", "CJKSymbolsandPunctuation", "Hiragana", "Katakana", "Bopomofo", "HangulCompatibilityJamo", "Kanbun", "BopomofoExtended", "CJKStrokes", "KatakanaPhoneticExtensions", "EnclosedCJKLettersandMonths", "CJKCompatibility", "CJKUnifiedIdeographsExtensionA", "YijingHexagramSymbols", "CJKUnifiedIdeographs", "YiSyllables", "YiRadicals", "Lisu", "Vai", "CyrillicExtended-B", "Bamum", "ModifierToneLetters", "LatinExtended-D", "SylotiNagri", "CommonIndicNumberForms", "Phags-pa", "Saurashtra", "DevanagariExtended", "KayahLi", "Rejang", "HangulJamoExtended-A", "Javanese", "MyanmarExtended-B", "Cham", "MyanmarExtended-A", "TaiViet", "MeeteiMayekExtensions", "EthiopicExtended-A", "LatinExtended-E", "CherokeeSupplement", "MeeteiMayek", "HangulSyllables", "HangulJamoExtended-B", "HighSurrogates", "HighPrivateUseSurrogates", "LowSurrogates", "PrivateUseArea|PrivateUse", "CJKCompatibilityIdeographs", "AlphabeticPresentationForms", "ArabicPresentationForms-A", "VariationSelectors", "VerticalForms", "CombiningHalfMarks", "CJKCompatibilityForms", "SmallFormVariants", "ArabicPresentationForms-B", "HalfwidthandFullwidthForms", "Specials", "LinearBSyllabary", "LinearBIdeograms", "AegeanNumbers", "AncientGreekNumbers", "AncientSymbols", "PhaistosDisc", null, "Lycian", "Carian", "CopticEpactNumbers", "OldItalic", "Gothic", "OldPermic", "Ugaritic", "OldPersian", null, "Deseret", "Shavian", "Osmanya", "Osage", "Elbasan", "CaucasianAlbanian", "Vithkuqi", null, "LinearA", "LatinExtended-F", null, "CypriotSyllabary", "ImperialAramaic", "Palmyrene", "Nabataean", null, "Hatran", "Phoenician", "Lydian", null, "MeroiticHieroglyphs", "MeroiticCursive", "Kharoshthi", "OldSouthArabian", "OldNorthArabian", null, "Manichaean", "Avestan", "InscriptionalParthian", "InscriptionalPahlavi", "PsalterPahlavi", null, "OldTurkic", null, "OldHungarian", "HanifiRohingya", null, "RumiNumeralSymbols", "Yezidi", "ArabicExtended-C", "OldSogdian", "Sogdian", "OldUyghur", "Chorasmian", "Elymaic", "Brahmi", "Kaithi", "SoraSompeng", "Chakma", "Mahajani", "Sharada", "SinhalaArchaicNumbers", "Khojki", null, "Multani", "Khudawadi", "Grantha", null, "Newa", "Tirhuta", null, "Siddham", "Modi", "MongolianSupplement", "Takri", null, "Ahom", null, "Dogra", null, "WarangCiti", "DivesAkuru", null, "Nandinagari", "ZanabazarSquare", "Soyombo", "UnifiedCanadianAboriginalSyllabicsExtended-A", "PauCinHau", "DevanagariExtended-A", null, "Bhaiksuki", "Marchen", null, "MasaramGondi", "GunjalaGondi", null, "Makasar", "Kawi", null, "LisuSupplement", "TamilSupplement", "Cuneiform", "CuneiformNumbersandPunctuation", "EarlyDynasticCuneiform", null, "Cypro-Minoan", "EgyptianHieroglyphs", "EgyptianHieroglyphFormatControls", null, "AnatolianHieroglyphs", null, "BamumSupplement", "Mro", "Tangsa", "BassaVah", "PahawhHmong", null, "Medefaidrin", null, "Miao", null, "IdeographicSymbolsandPunctuation", "Tangut", "TangutComponents", "KhitanSmallScript", "TangutSupplement", null, "KanaExtended-B", "KanaSupplement", "KanaExtended-A", "SmallKanaExtension", "Nushu", null, "Duployan", "ShorthandFormatControls", null, "ZnamennyMusicalNotation", null, "ByzantineMusicalSymbols", "MusicalSymbols", "AncientGreekMusicalNotation", null, "KaktovikNumerals", "MayanNumerals", "TaiXuanJingSymbols", "CountingRodNumerals", null, "MathematicalAlphanumericSymbols", "SuttonSignWriting", null, "LatinExtended-G", "GlagoliticSupplement", "CyrillicExtended-D", null, "NyiakengPuachueHmong", null, "Toto", "Wancho", null, "NagMundari", null, "EthiopicExtended-B", "MendeKikakui", null, "Adlam", null, "IndicSiyaqNumbers", null, "OttomanSiyaqNumbers", null, "ArabicMathematicalAlphabeticSymbols", null, "MahjongTiles", "DominoTiles", "PlayingCards", "EnclosedAlphanumericSupplement", "EnclosedIdeographicSupplement", "MiscellaneousSymbolsandPictographs", "Emoticons", "OrnamentalDingbats", "TransportandMapSymbols", "AlchemicalSymbols", "GeometricShapesExtended", "SupplementalArrows-C", "SupplementalSymbolsandPictographs", "ChessSymbols", "SymbolsandPictographsExtended-A", "SymbolsforLegacyComputing", null, "CJKUnifiedIdeographsExtensionB", null, "CJKUnifiedIdeographsExtensionC", "CJKUnifiedIdeographsExtensionD", "CJKUnifiedIdeographsExtensionE", "CJKUnifiedIdeographsExtensionF", null, "CJKCompatibilityIdeographsSupplement", null, "CJKUnifiedIdeographsExtensionG", "CJKUnifiedIdeographsExtensionH", null, "Tags", null, "VariationSelectorsSupplement", null, "SupplementaryPrivateUseArea-A|PrivateUse", "SupplementaryPrivateUseArea-B|PrivateUse"], [128, 128, 128, 208, 96, 80, 112, 144, 256, 48, 96, 112, 256, 80, 48, 64, 64, 64, 32, 16, 48, 96, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 256, 160, 96, 256, 384, 32, 96, 640, 32, 96, 32, 32, 32, 32, 128, 176, 80, 80, 48, 96, 32, 32, 144, 80, 128, 64, 64, 80, 48, 16, 48, 16, 48, 128, 64, 64, 256, 256, 112, 48, 48, 48, 80, 64, 112, 256, 256, 64, 32, 160, 128, 32, 96, 256, 192, 48, 16, 256, 128, 128, 256, 256, 96, 32, 128, 48, 80, 96, 32, 128, 128, 224, 16, 16, 64, 96, 96, 48, 96, 16, 32, 48, 16, 256, 256, 6592, 64, 20992, 1168, 64, 48, 320, 96, 96, 32, 224, 48, 16, 64, 96, 32, 48, 48, 32, 96, 32, 96, 32, 96, 32, 48, 64, 80, 64, 11184, 80, 896, 128, 1024, 6400, 512, 80, 688, 16, 16, 16, 32, 32, 144, 240, 16, 128, 128, 64, 80, 64, 48, 128, 32, 64, 32, 48, 32, 48, 32, 64, 32, 80, 48, 48, 80, 48, 64, 80, 64, 384, 64, 64, 64, 32, 32, 48, 48, 32, 32, 32, 64, 32, 96, 96, 32, 32, 32, 64, 64, 32, 32, 48, 80, 80, 48, 128, 64, 288, 32, 64, 64, 48, 64, 64, 48, 32, 128, 80, 48, 80, 48, 96, 32, 80, 48, 48, 80, 128, 128, 128, 96, 160, 128, 96, 32, 80, 48, 80, 176, 80, 80, 96, 96, 64, 96, 80, 96, 16, 64, 96, 160, 112, 80, 64, 96, 80, 304, 32, 96, 80, 16, 64, 1024, 128, 208, 2624, 112, 1072, 48, 4000, 640, 8576, 576, 48, 96, 48, 144, 688, 96, 96, 160, 64, 32, 6144, 768, 512, 128, 8816, 16, 256, 48, 64, 400, 2304, 160, 16, 4688, 208, 48, 256, 256, 80, 112, 32, 32, 96, 32, 128, 1024, 688, 1104, 256, 48, 96, 112, 80, 320, 48, 64, 464, 48, 736, 32, 224, 32, 96, 784, 80, 64, 80, 176, 256, 256, 48, 112, 96, 256, 256, 768, 80, 48, 128, 128, 128, 256, 256, 112, 144, 256, 1024, 42720, 32, 4160, 224, 5776, 7488, 3088, 544, 1504, 4944, 4192, 711760, 128, 128, 240, 65040, 65536, 65536]);
+var x = function(A) {
+  const n3 = new Map, G2 = A.split(""), i3 = M.map(() => []);
+  let r3 = 0, o3 = 0;
+  for (;o3 < G2.length; ) {
+    const A2 = J[G2[o3]], n4 = (31 & A2) - 2;
+    let e3 = 1 + J[G2[o3 + 1]];
+    switch (32 & A2 ? (e3 += J[G2[o3 + 2]] << 6, e3 += J[G2[o3 + 3]] << 12, e3 += J[G2[o3 + 4]] << 18, o3 += 5) : o3 += 2, n4) {
+      case -2: {
+        let A3 = 0;
+        for (let a3 = r3;a3 < r3 + e3; ++a3) {
+          i3[A3].push(B(a3)), A3 = (A3 + 1) % 2;
+        }
+        break;
+      }
+      case -1:
+        break;
+      default: {
+        const A3 = i3[n4];
+        e3 === 1 ? A3.push(B(r3)) : A3.push(a2(r3, r3 + e3 - 1));
+        break;
+      }
+    }
+    r3 += e3;
+  }
+  const l3 = new Map;
+  return M.forEach((A2, B2) => {
+    const a3 = i3[B2].reduce(t2, e2);
+    n3.set(A2, a3);
+    const G3 = A2.charAt(0), r4 = l3.get(G3) || [];
+    l3.set(G3, r4), r4.push(a3);
+  }), l3.forEach((A2, B2) => {
+    n3.set(B2, A2.reduce(t2, e2));
+  }), n3;
+}("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");
+function L(A) {
+  return A === 32 || A === 9 || A === 10 || A === 13;
+}
+var X = [B(S(":")), a2(S("A"), S("Z")), B(S("_")), a2(S("a"), S("z")), a2(192, 214), a2(216, 246), a2(192, 214), a2(216, 246), a2(248, 767), a2(880, 893), a2(895, 8191), a2(8204, 8205), a2(8304, 8591), a2(11264, 12271), a2(12289, 55295), a2(63744, 64975), a2(65008, 65533), a2(65536, 983039)].reduce(t2);
+var Z = [X, B(S("-")), B(S(".")), a2(S("0"), S("9")), B(183), a2(768, 879), a2(8255, 8256)].reduce(t2);
+var O = x.get("Nd");
+var k = b(O);
+var N = y(a2(0, 1114111), [x.get("P"), x.get("Z"), x.get("C")].reduce(t2));
+var v = b(N);
+function w2(A) {
+  return A !== 10 && A !== 13 && !K(A);
+}
+var Y = { s: L, S: b(L), i: X, I: b(X), c: Z, C: b(Z), d: O, D: k, w: N, W: v };
+var U = C("*");
+var j = C("\\");
+var R = C("{");
+var V = C("}");
+var W = C("[");
+var q = C("]");
+var z = C("^");
+var $ = C("$");
+var _ = C(",");
+var AA = C("-");
+var BA = C("(");
+var aA = C(")");
+var nA = C(".");
+var eA = C("|");
+var tA = C("+");
+var GA = C("?");
+var iA = C("-[");
+var rA = S("0");
+function oA(A) {
+  function e3(A2) {
+    return new Set(A2.split("").map((A3) => S(A3)));
+  }
+  function G2(A2, B2) {
+    const a3 = A2.codePointAt(B2);
+    return a3 === undefined ? H(B2, ["any character"]) : o2(B2 + String.fromCodePoint(a3).length, a3);
+  }
+  const i3 = A.language === "xpath" ? T(j, c2([u2(C("n"), () => 10), u2(C("r"), () => 13), u2(C("t"), () => 9), u2(c2([j, eA, nA, AA, z, GA, U, tA, R, V, $, BA, aA, W, q]), (A2) => S(A2))])) : T(j, c2([u2(C("n"), () => 10), u2(C("r"), () => 13), u2(C("t"), () => 9), u2(c2([j, eA, nA, AA, z, GA, U, tA, R, V, BA, aA, W, q]), (A2) => S(A2))]));
+  function r3(A2, B2) {
+    const a3 = e3(B2);
+    return I(C(A2), D(s2(G2, (A3) => a3.has(A3), B2.split(""))), (A3, B3) => function(A4) {
+      const B4 = x.get(A4);
+      if (B4 == null)
+        throw new Error(A4 + " is not a valid unicode category");
+      return B4;
+    }(B3 === null ? A3 : A3 + String.fromCodePoint(B3)));
+  }
+  const l3 = c2([r3("L", "ultmo"), r3("M", "nce"), r3("N", "dlo"), r3("P", "cdseifo"), r3("Z", "slp"), r3("S", "mcko"), r3("C", "cfon")]), p2 = [a2(S("a"), S("z")), a2(S("A"), S("Z")), a2(S("0"), S("9")), B(45)].reduce(t2), M2 = c2([l3, u2(T(C("Is"), function(A2) {
+    return (B2, a3) => {
+      const n3 = A2(B2, a3);
+      return n3.success ? o2(n3.offset, B2.slice(a3, n3.offset)) : n3;
+    };
+  }(d2(s2(G2, p2, ["block identifier"])))), (B2) => function(A2, B3) {
+    const a3 = Q.get(A2);
+    if (a3 === undefined) {
+      if (B3)
+        return n2;
+      throw new Error(`The unicode block identifier "${A2}" is not known.`);
+    }
+    return a3;
+  }(B2, A.language !== "xpath"))]), J2 = E(C("\\p{"), M2, V, true), K2 = u2(E(C("\\P{"), M2, V, true), b), L2 = T(j, u2(c2("sSiIcCdDwW".split("").map((A2) => C(A2))), (A2) => Y[A2])), X2 = u2(nA, () => w2), Z2 = c2([L2, J2, K2]), O2 = e3("\\[]"), k2 = c2([i3, s2(G2, (A2) => !O2.has(A2), ["unescaped character"])]), N2 = c2([u2(AA, () => null), k2]), v2 = I(N2, T(AA, N2), a2);
+  function oA2(A2, B2) {
+    return [A2].concat(B2 || []);
+  }
+  const lA = u2(function(A2) {
+    return (B2, a3) => {
+      const n3 = A2(B2, a3);
+      return n3.success ? o2(a3, n3.value) : n3;
+    };
+  }(c2([q, iA])), () => null), HA = S("-"), CA = c2([u2(F(F(AA, g(W, ["not ["])), lA), () => HA), T(g(AA, ["not -"]), k2)]), uA = c2([I(u2(CA, B), c2([function(A2, B2) {
+    return uA(A2, B2);
+  }, lA]), oA2), I(c2([v2, Z2]), c2([cA, lA]), oA2)]);
+  const sA = c2([I(u2(k2, B), c2([uA, lA]), oA2), I(c2([v2, Z2]), c2([cA, lA]), oA2)]);
+  function cA(A2, B2) {
+    return sA(A2, B2);
+  }
+  const DA = u2(sA, (A2) => A2.reduce(t2)), mA = u2(T(z, DA), b), IA = I(c2([T(g(z, ["not ^"]), DA), mA]), D(T(AA, function(A2, B2) {
+    return dA(A2, B2);
+  })), y), dA = E(W, IA, q, true);
+  const hA = A.language === "xpath" ? c2([u2(i3, B), Z2, dA, X2, u2(z, () => (A2) => A2 === -1), u2($, () => (A2) => A2 === -2)]) : c2([u2(i3, B), Z2, dA, X2]), pA = A.language === "xpath" ? e3(".\\?*+{}()|^$[]") : e3(".\\?*+{}()|[]"), TA = s2(G2, (A2) => !pA.has(A2), ["NormalChar"]), FA = u2(T(j, I(u2(s2(G2, a2(S("1"), S("9")), ["digit"]), (A2) => A2 - rA), m(u2(s2(G2, a2(rA, S("9")), ["digit"]), (A2) => A2 - rA)), (A2, B2) => {
+    B2.reduce((A3, B3) => 10 * A3 + B3, A2);
+  })), (A2) => {
+    throw new Error("Backreferences in XPath patterns are not yet implemented.");
+  }), EA = A.language === "xpath" ? c2([u2(TA, (A2) => ({ kind: "predicate", value: B(A2) })), u2(hA, (A2) => ({ kind: "predicate", value: A2 })), u2(E(BA, T(D(C("?:")), SA), aA, true), (A2) => ({ kind: "regexp", value: A2 })), FA]) : c2([u2(TA, (A2) => ({ kind: "predicate", value: B(A2) })), u2(hA, (A2) => ({ kind: "predicate", value: A2 })), u2(E(BA, SA, aA, true), (A2) => ({ kind: "regexp", value: A2 }))]), gA = u2(d2(u2(s2(G2, a2(rA, S("9")), ["digit"]), (A2) => A2 - rA)), (A2) => A2.reduce((A3, B2) => 10 * A3 + B2)), fA = c2([I(gA, T(_, gA), (A2, B2) => {
+    if (B2 < A2)
+      throw new Error("quantifier range is in the wrong order");
+    return { min: A2, max: B2 };
+  }), I(gA, _, (A2) => ({ min: A2, max: null })), u2(gA, (A2) => ({ min: A2, max: A2 }))]), PA = A.language === "xpath" ? I(c2([u2(GA, () => ({ min: 0, max: 1 })), u2(U, () => ({ min: 0, max: null })), u2(tA, () => ({ min: 1, max: null })), E(R, fA, V, true)]), D(GA), (A2, B2) => A2) : c2([u2(GA, () => ({ min: 0, max: 1 })), u2(U, () => ({ min: 0, max: null })), u2(tA, () => ({ min: 1, max: null })), E(R, fA, V, true)]), MA = m(I(EA, u2(D(PA), (A2) => A2 === null ? { min: 1, max: 1 } : A2), (A2, B2) => [A2, B2])), JA = I(MA, m(T(eA, f2(MA))), (A2, B2) => [A2].concat(B2));
+  function SA(A2, B2) {
+    return JA(A2, B2);
+  }
+  const KA = function(A2) {
+    return I(A2, P, h2);
+  }(JA);
+  return function(A2) {
+    let B2;
+    try {
+      B2 = KA(A2, 0);
+    } catch (B3) {
+      throw new Error(`Error parsing pattern "${A2}": ${B3 instanceof Error ? B3.message : B3}`);
+    }
+    return B2.success ? B2.value : function(A3, B3, a3) {
+      const n3 = a3.map((A4) => `"${A4}"`);
+      throw new Error(`Error parsing pattern "${A3}" at offset ${B3}: expected ${n3.length > 1 ? "one of " + n3.join(", ") : n3[0]} but found "${A3.slice(B3, B3 + 1)}"`);
+    }(A2, B2.offset, B2.expected);
+  };
+}
+function lA(A) {
+  return [...A].map((A2) => A2.codePointAt(0));
+}
+function HA(B2, a3 = { language: "xsd" }) {
+  const n3 = oA(a3)(B2), e3 = w((A) => {
+    r2(A, n3, a3.language === "xpath"), A.accept();
+  });
+  return function(A) {
+    const B3 = a3.language === "xpath" ? [-1, ...lA(A), -2] : lA(A);
+    return e3.execute(B3).success;
+  };
+}
+
 // src/types.ts
 function isResponseRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -772,47 +1568,47 @@ function booleanValue(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) {
+function pairsEqual2(a3, b2, directed) {
+  const [a1, a22] = a3.trim().split(/\s+/u);
+  const [b1, b22] = b2.trim().split(/\s+/u);
+  if (a1 === undefined || a22 === undefined || b1 === undefined || b22 === undefined) {
     return false;
   }
-  if (a1 === b1 && a2 === b2) {
+  if (a1 === b1 && a22 === b22) {
     return true;
   }
-  return !directed && a1 === b2 && a2 === b1;
+  return !directed && a1 === b22 && a22 === b1;
 }
-function scalarsEqual(a, b, baseType, normalize) {
+function scalarsEqual(a3, b2, baseType, normalize) {
   if (baseType === "pair" || baseType === "directedPair") {
-    return typeof a === "string" && typeof b === "string" && pairsEqual2(a, b, baseType === "directedPair");
+    return typeof a3 === "string" && typeof b2 === "string" && pairsEqual2(a3, b2, baseType === "directedPair");
   }
   if (baseType === "point") {
-    if (typeof a !== "string" || typeof b !== "string") {
+    if (typeof a3 !== "string" || typeof b2 !== "string") {
       return false;
     }
-    const pointA = parsePoint(a);
-    const pointB = parsePoint(b);
+    const pointA = parsePoint(a3);
+    const pointB = parsePoint(b2);
     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 (typeof a3 === "number" || typeof b2 === "number") {
+    return Number(a3) === Number(b2);
   }
-  if (normalize && baseType === "string" && typeof a === "string" && typeof b === "string") {
-    return normalize(a) === normalize(b);
+  if (normalize && baseType === "string" && typeof a3 === "string" && typeof b2 === "string") {
+    return normalize(a3) === normalize(b2);
   }
-  return a === b;
+  return a3 === b2;
 }
-function valuesMatch(a, b, normalize) {
-  const baseType = a.baseType ?? b.baseType;
-  if (a.values.length !== b.values.length) {
+function valuesMatch(a3, b2, normalize) {
+  const baseType = a3.baseType ?? b2.baseType;
+  if (a3.values.length !== b2.values.length) {
     return false;
   }
-  if (a.cardinality === "ordered" || b.cardinality === "ordered") {
-    return a.values.every((value, index) => scalarsEqual(value, b.values[index], baseType, normalize));
+  if (a3.cardinality === "ordered" || b2.cardinality === "ordered") {
+    return a3.values.every((value, index) => scalarsEqual(value, b2.values[index], baseType, normalize));
   }
-  const remaining = [...b.values];
-  for (const value of a.values) {
+  const remaining = [...b2.values];
+  for (const value of a3.values) {
     const matchIndex = remaining.findIndex((candidate) => scalarsEqual(candidate, value, baseType, normalize));
     if (matchIndex === -1) {
       return false;
@@ -844,10 +1640,16 @@ function toOutcomeValue(value) {
 // src/rp/evaluate.ts
 var deterministicExpressionKinds = new Set([
   "and",
+  "anyN",
   "baseValue",
+  "containerSize",
+  "contains",
   "correct",
+  "default",
   "delete",
   "divide",
+  "durationGte",
+  "durationLt",
   "equal",
   "equalRounded",
   "fieldValue",
@@ -873,8 +1675,11 @@ var deterministicExpressionKinds = new Set([
   "min",
   "multiple",
   "not",
+  "null",
   "or",
   "ordered",
+  "patternMatch",
+  "power",
   "product",
   "repeat",
   "round",
@@ -897,68 +1702,94 @@ class RpUnsupportedError extends Error {
   }
 }
 var mathConstants = { pi: Math.PI, e: Math.E };
-function applyMathOperator(name, x, y) {
+var xsdPatternMatchers = new Map;
+function xsdPatternMatcher(pattern) {
+  const cached = xsdPatternMatchers.get(pattern);
+  if (cached !== undefined) {
+    return cached;
+  }
+  let matcher;
+  try {
+    matcher = HA(pattern);
+  } catch {
+    matcher = null;
+  }
+  xsdPatternMatchers.set(pattern, matcher);
+  return matcher;
+}
+var encVariableStringPattern = /^\{[^{}]+\}$/u;
+function applyMathOperator(name, x2, y2) {
   switch (name) {
     case "sin":
-      return Math.sin(x);
+      return Math.sin(x2);
     case "cos":
-      return Math.cos(x);
+      return Math.cos(x2);
     case "tan":
-      return Math.tan(x);
+      return Math.tan(x2);
     case "sec":
-      return 1 / Math.cos(x);
+      return 1 / Math.cos(x2);
     case "csc":
-      return 1 / Math.sin(x);
+      return 1 / Math.sin(x2);
     case "cot":
-      return Math.cos(x) / Math.sin(x);
+      return Math.cos(x2) / Math.sin(x2);
     case "asin":
-      return Math.asin(x);
+      return Math.asin(x2);
     case "acos":
-      return Math.acos(x);
+      return Math.acos(x2);
     case "atan":
-      return Math.atan(x);
+      return Math.atan(x2);
     case "atan2":
-      return Math.atan2(x, y);
+      return Math.atan2(x2, y2);
     case "asec":
-      return Math.acos(1 / x);
+      return Math.acos(1 / x2);
     case "acsc":
-      return Math.asin(1 / x);
+      return Math.asin(1 / x2);
     case "acot":
-      return Math.atan(1 / x);
+      return Math.atan(1 / x2);
     case "sinh":
-      return Math.sinh(x);
+      return Math.sinh(x2);
     case "cosh":
-      return Math.cosh(x);
+      return Math.cosh(x2);
     case "tanh":
-      return Math.tanh(x);
+      return Math.tanh(x2);
     case "sech":
-      return 1 / Math.cosh(x);
+      return 1 / Math.cosh(x2);
     case "csch":
-      return 1 / Math.sinh(x);
+      return 1 / Math.sinh(x2);
     case "coth":
-      return Math.cosh(x) / Math.sinh(x);
+      return Math.cosh(x2) / Math.sinh(x2);
     case "log":
-      return Math.log10(x);
+      return Math.log10(x2);
     case "ln":
-      return Math.log(x);
+      return Math.log(x2);
     case "exp":
-      return Math.exp(x);
+      return Math.exp(x2);
     case "abs":
-      return Math.abs(x);
+      return Math.abs(x2);
     case "signum":
-      return Math.sign(x);
+      return Math.sign(x2);
     case "floor":
-      return Math.floor(x);
+      return Math.floor(x2);
     case "ceil":
-      return Math.ceil(x);
+      return Math.ceil(x2);
     case "toDegrees":
-      return x * 180 / Math.PI;
+      return x2 * 180 / Math.PI;
     case "toRadians":
-      return x * Math.PI / 180;
+      return x2 * Math.PI / 180;
     default:
       return;
   }
 }
+function resolveNumericAttribute(raw, env) {
+  if (raw === undefined) {
+    return;
+  }
+  if (typeof raw === "number") {
+    return raw;
+  }
+  const identifier = raw.startsWith("{") && raw.endsWith("}") ? raw.slice(1, -1) : raw;
+  return singleNumber(env.lookupVariable(identifier));
+}
 function roundToFigures(value, mode, figures) {
   if (mode === "decimalPlaces") {
     const scale2 = 10 ** figures;
@@ -1010,11 +1841,11 @@ function evaluateExpression(expression, env) {
       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) {
+      const [a3, b2] = (expression.expressions ?? []).map(evaluate);
+      if (a3 === undefined || b2 === undefined || a3 === null || b2 === null) {
         return null;
       }
-      return booleanValue(valuesMatch(a, b, env.normalization));
+      return booleanValue(valuesMatch(a3, b2, env.normalization));
     }
     case "isNull": {
       const operand = expression.expressions?.[0];
@@ -1034,7 +1865,16 @@ function evaluateExpression(expression, env) {
     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));
+      if (expression.kind === "and") {
+        if (members.some((member) => member === false)) {
+          return booleanValue(false);
+        }
+        return members.some((member) => member === null) ? null : booleanValue(true);
+      }
+      if (members.some((member) => member === true)) {
+        return booleanValue(true);
+      }
+      return members.some((member) => member === null) ? null : booleanValue(false);
     }
     case "sum":
     case "product": {
@@ -1055,44 +1895,45 @@ function evaluateExpression(expression, env) {
     }
     case "subtract":
     case "divide": {
-      const [a, b] = (expression.expressions ?? []).map((child) => singleNumber(evaluate(child)));
-      if (a === undefined || b === undefined || a === null || b === null) {
+      const [a3, b2] = (expression.expressions ?? []).map((child) => singleNumber(evaluate(child)));
+      if (a3 === undefined || b2 === undefined || a3 === null || b2 === null) {
         return null;
       }
       if (expression.kind === "divide") {
-        return b === 0 ? null : floatValue(a / b);
+        return b2 === 0 ? null : floatValue(a3 / b2);
       }
-      return floatValue(a - b);
+      return floatValue(a3 - b2);
     }
     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) {
+      const [a3, b2] = (expression.expressions ?? []).map((child) => singleNumber(evaluate(child)));
+      if (a3 === undefined || b2 === undefined || a3 === null || b2 === null) {
         return null;
       }
-      const comparisons = { gt: a > b, gte: a >= b, lt: a < b, lte: a <= b };
+      const comparisons = { gt: a3 > b2, gte: a3 >= b2, lt: a3 < b2, lte: a3 <= b2 };
       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) {
+      const [a3, b2] = (expression.expressions ?? []).map((child) => singleNumber(evaluate(child)));
+      if (a3 === undefined || b2 === undefined || a3 === null || b2 === null) {
         return null;
       }
       const mode = expression.toleranceMode ?? "exact";
       if (mode === "exact") {
-        return booleanValue(a === b);
+        return booleanValue(a3 === b2);
       }
-      const t0 = expression.tolerance?.[0];
-      const t1 = expression.tolerance?.[1] ?? t0;
+      const t0 = resolveNumericAttribute(expression.tolerance?.[0], env);
+      const t1raw = expression.tolerance?.[1];
+      const t1 = t1raw === undefined ? t0 : resolveNumericAttribute(t1raw, env);
       if (typeof t0 !== "number" || typeof t1 !== "number") {
-        throw new RpUnsupportedError("equal");
+        return null;
       }
-      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;
+      const lower = mode === "absolute" ? a3 - t0 : a3 * (1 - t0 / 100);
+      const upper = mode === "absolute" ? a3 + t1 : a3 * (1 + t1 / 100);
+      const aboveLower = expression.includeLowerBound ?? true ? b2 >= lower : b2 > lower;
+      const belowUpper = expression.includeUpperBound ?? true ? b2 <= upper : b2 < upper;
       return booleanValue(aboveLower && belowUpper);
     }
     case "round":
@@ -1106,15 +1947,16 @@ function evaluateExpression(expression, env) {
       return { cardinality: "single", baseType: "integer", values: [rounded] };
     }
     case "index": {
-      if (typeof expression.n !== "number") {
-        throw new RpUnsupportedError("index");
+      const n3 = resolveNumericAttribute(expression.n, env);
+      if (typeof n3 !== "number") {
+        return null;
       }
       const operand = expression.expressions?.[0];
       const container = operand === undefined ? null : evaluate(operand);
       if (container === null) {
         return null;
       }
-      const member = container.values[expression.n - 1];
+      const member = container.values[n3 - 1];
       if (member === undefined) {
         return null;
       }
@@ -1128,11 +1970,11 @@ function evaluateExpression(expression, env) {
       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)) {
+      const [x2, y2] = (expression.expressions ?? []).map((child) => singleNumber(evaluate(child)));
+      if (x2 === undefined || x2 === null || expression.name === "atan2" && (y2 === undefined || y2 === null)) {
         return null;
       }
-      const result = expression.name === undefined ? undefined : applyMathOperator(expression.name, x, y ?? NaN);
+      const result = expression.name === undefined ? undefined : applyMathOperator(expression.name, x2, y2 ?? NaN);
       if (result === undefined) {
         throw new RpUnsupportedError("mathOperator");
       }
@@ -1140,11 +1982,11 @@ function evaluateExpression(expression, env) {
     }
     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) {
+      const [a3, b2] = (expression.expressions ?? []).map((child) => singleNumber(evaluate(child)));
+      if (a3 === undefined || b2 === undefined || a3 === null || b2 === null || b2 === 0) {
         return null;
       }
-      const result = expression.kind === "integerDivide" ? Math.trunc(a / b) : a % b;
+      const result = expression.kind === "integerDivide" ? Math.trunc(a3 / b2) : a3 % b2;
       return { cardinality: "single", baseType: "integer", values: [result] };
     }
     case "integerToFloat": {
@@ -1190,33 +2032,35 @@ function evaluateExpression(expression, env) {
       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);
+      const gcdOf = (a3, b2) => b2 === 0 ? a3 : gcdOf(b2, a3 % b2);
+      const result = expression.kind === "gcd" ? members.reduce(gcdOf) : members.reduce((a3, b2) => a3 === 0 || b2 === 0 ? 0 : a3 / gcdOf(a3, b2) * b2);
       return { cardinality: "single", baseType: "integer", values: [result] };
     }
     case "roundTo": {
-      if (typeof expression.figures !== "number") {
-        throw new RpUnsupportedError("roundTo");
+      const figures = resolveNumericAttribute(expression.figures, env);
+      if (typeof figures !== "number") {
+        return null;
       }
       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);
+      const rounded = roundToFigures(value, expression.roundingMode ?? "significantFigures", figures);
       return rounded === null ? null : floatValue(rounded);
     }
     case "equalRounded": {
-      if (typeof expression.figures !== "number") {
-        throw new RpUnsupportedError("equalRounded");
+      const figures = resolveNumericAttribute(expression.figures, env);
+      if (typeof figures !== "number") {
+        return null;
       }
-      const [a, b] = (expression.expressions ?? []).map((child) => singleNumber(evaluate(child)));
-      if (a === undefined || b === undefined || a === null || b === null) {
+      const [a3, b2] = (expression.expressions ?? []).map((child) => singleNumber(evaluate(child)));
+      if (a3 === undefined || b2 === undefined || a3 === null || b2 === null) {
         return null;
       }
       const mode = expression.roundingMode ?? "significantFigures";
-      const roundedA = roundToFigures(a, mode, expression.figures);
-      const roundedB = roundToFigures(b, mode, expression.figures);
+      const roundedA = roundToFigures(a3, mode, figures);
+      const roundedB = roundToFigures(b2, mode, figures);
       return roundedA === null || roundedB === null ? null : booleanValue(roundedA === roundedB);
     }
     case "statsOperator": {
@@ -1272,15 +2116,13 @@ function evaluateExpression(expression, env) {
       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) {
+      const numberRepeats = resolveNumericAttribute(expression.numberRepeats, env);
+      if (typeof numberRepeats !== "number" || numberRepeats < 1) {
         return null;
       }
       const members = [];
       let baseType;
-      for (let pass = 0;pass < expression.numberRepeats; pass += 1) {
+      for (let pass = 0;pass < numberRepeats; pass += 1) {
         for (const child of expression.expressions ?? []) {
           const value = evaluate(child);
           if (value === null) {
@@ -1292,21 +2134,112 @@ function evaluateExpression(expression, env) {
       }
       return members.length === 0 ? null : rpValue("ordered", members, baseType);
     }
+    case "null":
+      return null;
+    case "durationGte":
+    case "durationLt": {
+      const [a3, b2] = (expression.expressions ?? []).map((child) => singleNumber(evaluate(child)));
+      if (a3 === undefined || b2 === undefined || a3 === null || b2 === null) {
+        return null;
+      }
+      return booleanValue(expression.kind === "durationGte" ? a3 >= b2 : a3 < b2);
+    }
+    case "default":
+      return env.variableDefault?.(expression.identifier ?? "") ?? null;
+    case "patternMatch": {
+      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;
+      }
+      if (expression.pattern === undefined) {
+        throw new RpUnsupportedError("patternMatch");
+      }
+      const pattern = encVariableStringPattern.test(expression.pattern) ? env.lookupVariable(expression.pattern.slice(1, -1))?.values[0] : expression.pattern;
+      if (typeof pattern !== "string") {
+        return null;
+      }
+      const matcher = xsdPatternMatcher(pattern);
+      if (matcher === null) {
+        throw new RpUnsupportedError("patternMatch");
+      }
+      return booleanValue(matcher(member));
+    }
+    case "power": {
+      const [a3, b2] = (expression.expressions ?? []).map((child) => singleNumber(evaluate(child)));
+      if (a3 === undefined || b2 === undefined || a3 === null || b2 === null) {
+        return null;
+      }
+      const result = a3 ** b2;
+      return Number.isFinite(result) ? floatValue(result) : null;
+    }
+    case "containerSize": {
+      const operand = expression.expressions?.[0];
+      const container = operand === undefined ? null : evaluate(operand);
+      return {
+        cardinality: "single",
+        baseType: "integer",
+        values: [container === null ? 0 : container.values.length]
+      };
+    }
+    case "contains": {
+      const [firstExpression, secondExpression] = expression.expressions ?? [];
+      if (firstExpression === undefined || secondExpression === undefined) {
+        return null;
+      }
+      const first = evaluate(firstExpression);
+      const second = evaluate(secondExpression);
+      if (first === null || second === null || first.cardinality === "record" || second.cardinality === "record") {
+        return null;
+      }
+      const baseType = first.baseType ?? second.baseType;
+      if (first.cardinality === "ordered") {
+        const found = first.values.some((_2, start) => start + second.values.length <= first.values.length && second.values.every((member, offset) => scalarsEqual(first.values[start + offset], member, baseType, env.normalization)));
+        return booleanValue(found);
+      }
+      const remaining = [...first.values];
+      for (const member of second.values) {
+        const at = remaining.findIndex((candidate) => scalarsEqual(candidate, member, baseType, env.normalization));
+        if (at === -1) {
+          return booleanValue(false);
+        }
+        remaining.splice(at, 1);
+      }
+      return booleanValue(true);
+    }
+    case "anyN": {
+      const min = resolveNumericAttribute(expression.min, env);
+      const max = resolveNumericAttribute(expression.max, env);
+      if (typeof min !== "number" || typeof max !== "number") {
+        return null;
+      }
+      const members = (expression.expressions ?? []).map((child) => singleBoolean(evaluate(child)));
+      const trueCount = members.filter((member) => member === true).length;
+      const nullCount = members.filter((member) => member === null).length;
+      if (trueCount >= min && trueCount + nullCount <= max) {
+        return booleanValue(true);
+      }
+      if (trueCount + nullCount < min || trueCount > max) {
+        return booleanValue(false);
+      }
+      return null;
+    }
     case "stringMatch":
     case "substring": {
-      const [a, b] = (expression.expressions ?? []).map((child) => {
+      const [a3, b2] = (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) {
+      if (a3 === undefined || b2 === undefined || a3 === null || b2 === 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 [left, right] = [normalize(a3), normalize(b2)];
       const contains = expression.kind === "substring" || expression.substring === true;
       return booleanValue(contains ? right.includes(left) : left === right);
     }
@@ -1364,9 +2297,9 @@ function evaluateExpression(expression, env) {
       if (!env.random) {
         throw new RpUnsupportedError(expression.kind);
       }
-      const min = expression.min ?? 0;
-      const max = expression.max ?? min;
-      const step = expression.step ?? 1;
+      const min = resolveNumericAttribute(expression.min, env) ?? 0;
+      const max = resolveNumericAttribute(expression.max, env) ?? min;
+      const step = resolveNumericAttribute(expression.step, env) ?? 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] };
     }
@@ -1374,8 +2307,8 @@ function evaluateExpression(expression, env) {
       if (!env.random) {
         throw new RpUnsupportedError(expression.kind);
       }
-      const min = expression.min ?? 0;
-      const max = expression.max ?? min;
+      const min = resolveNumericAttribute(expression.min, env) ?? 0;
+      const max = resolveNumericAttribute(expression.max, env) ?? min;
       return floatValue(min + env.random() * (max - min));
     }
     case "testVariables": {
@@ -1395,7 +2328,9 @@ function evaluateExpression(expression, env) {
     case "numberIncorrect":
     case "numberPresented":
     case "numberResponded":
-    case "numberSelected": {
+    case "numberSelected":
+    case "outcomeMinimum":
+    case "outcomeMaximum": {
       if (!env.testAggregate) {
         throw new RpUnsupportedError(expression.kind);
       }
@@ -1423,12 +2358,35 @@ function collectExpressionIssues(expression, allowedKinds, report, customOperato
     }
   } else if (!allowedKinds.has(expression.kind)) {
     report(expression.kind);
+  } else if (expression.kind === "patternMatch" && expression.pattern !== undefined && !encVariableStringPattern.test(expression.pattern) && xsdPatternMatcher(expression.pattern) === null) {
+    report(expression.kind);
   }
   for (const child of expression.expressions ?? []) {
     collectExpressionIssues(child, allowedKinds, report, customOperatorClasses);
   }
 }
 
+// src/rp/lookup-table.ts
+function hasLookupTable(declaration) {
+  return declaration?.matchTable !== undefined || declaration?.interpolationTable !== undefined;
+}
+function lookupTableValue(declaration, source) {
+  const value = singleNumber(source);
+  const table = declaration.matchTable ?? declaration.interpolationTable;
+  const target = value === null ? undefined : matchedTarget(declaration, value);
+  const result = target ?? table?.defaultValue;
+  if (result === undefined) {
+    return null;
+  }
+  return rpValue("single", [coerceScalar(result, declaration.baseType)], declaration.baseType);
+}
+function matchedTarget(declaration, value) {
+  if (declaration.matchTable) {
+    return declaration.matchTable.matchTableEntries.find((entry) => entry.sourceValue === value)?.targetValue;
+  }
+  return declaration.interpolationTable?.interpolationTableEntries.find((entry) => entry.includeBoundary ?? true ? entry.sourceValue <= value : entry.sourceValue < value)?.targetValue;
+}
+
 // src/rp/templates.ts
 var matchCorrectRules = [
   {
@@ -1598,7 +2556,13 @@ function resolveTemplate(uri) {
 }
 
 // src/rp/interpreter.ts
-var supportedRuleKinds = new Set(["responseCondition", "setOutcomeValue", "exitResponse"]);
+var supportedRuleKinds = new Set([
+  "responseCondition",
+  "setOutcomeValue",
+  "lookupOutcomeValue",
+  "responseProcessingFragment",
+  "exitResponse"
+]);
 var rpExpressionKinds = new Set([...deterministicExpressionKinds, "random", "randomInteger", "randomFloat"]);
 
 class ExitResponseSignal extends Error {
@@ -1620,6 +2584,9 @@ function executeResponseProcessing(view, context) {
   const templateDeclarationsById = new Map((context.templateDeclarations ?? []).map((declaration) => [declaration.identifier, declaration]));
   function initialOutcomes() {
     const outcomes2 = defaultOutcomes(context.outcomeDeclarations);
+    if (!outcomes2.has("completionStatus")) {
+      outcomes2.set("completionStatus", rpValue("single", [context.completionStatus ?? "not_attempted"], "identifier"));
+    }
     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));
@@ -1638,6 +2605,12 @@ function executeResponseProcessing(view, context) {
   }
   const env = {
     lookupVariable: (identifier) => {
+      if (identifier === "duration") {
+        return context.duration === undefined ? null : rpValue("single", [context.duration], "duration");
+      }
+      if (identifier === "numAttempts") {
+        return context.numAttempts === undefined ? null : rpValue("single", [context.numAttempts], "integer");
+      }
       const declaration = declarationsById.get(identifier);
       if (declaration) {
         return fromResponse(declaration, context.responses[identifier] ?? null);
@@ -1650,6 +2623,13 @@ function executeResponseProcessing(view, context) {
     },
     responseDeclaration: (identifier) => declarationsById.get(identifier),
     responseValue: (identifier) => context.responses[identifier] ?? null,
+    variableDefault: (identifier) => {
+      const declaration = declarationsById.get(identifier) ?? context.outcomeDeclarations.find((entry) => entry.identifier === identifier) ?? templateDeclarationsById.get(identifier);
+      if (!declaration?.defaultValue) {
+        return null;
+      }
+      return rpValue(declaration.cardinality, declaration.defaultValue.values.map((entry) => coerceScalar(entry.value, declaration.baseType)), declaration.baseType);
+    },
     normalization: context.normalization,
     random: context.random,
     customOperators: context.customOperators
@@ -1675,6 +2655,20 @@ function executeResponseProcessing(view, context) {
         }
         continue;
       }
+      if (rule.kind === "responseProcessingFragment") {
+        executeRules(rule.rules ?? []);
+        continue;
+      }
+      if (rule.kind === "lookupOutcomeValue") {
+        if (rule.identifier !== undefined && rule.expression !== undefined) {
+          const declaration = context.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.responseIf && branchTaken(rule.responseIf)) {
         continue;
       }
@@ -1717,9 +2711,18 @@ function collectRpIssues(view, options) {
         report(rule.kind);
         continue;
       }
+      if (rule.kind === "lookupOutcomeValue" && options?.outcomeDeclarations !== undefined) {
+        const declaration = options.outcomeDeclarations.find((entry) => entry.identifier === rule.identifier);
+        if (!hasLookupTable(declaration)) {
+          report("lookupOutcomeValue", "Outcome declaration has no matchTable/interpolationTable.");
+        }
+      }
       if (rule.expression) {
         collectExpressionIssues(rule.expression, rpExpressionKinds, report, options?.customOperatorClasses);
       }
+      if (rule.rules) {
+        walkRules(rule.rules);
+      }
       for (const branch of [rule.responseIf, ...rule.responseElseIfs ?? []]) {
         if (branch) {
           collectExpressionIssues(branch.expression, rpExpressionKinds, report, options?.customOperatorClasses);
@@ -1761,10 +2764,10 @@ 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;
+    let t3 = state;
+    t3 = Math.imul(t3 ^ t3 >>> 15, t3 | 1);
+    t3 ^= t3 + Math.imul(t3 ^ t3 >>> 7, t3 | 61);
+    return ((t3 ^ t3 >>> 14) >>> 0) / 4294967296;
   };
 }
 function executeTemplateProcessing(view, context) {
@@ -1784,6 +2787,13 @@ function executeTemplateProcessing(view, context) {
     lookupVariable: (identifier) => templateValues.get(identifier) ?? null,
     responseDeclaration: (identifier) => responseDeclarationsById.get(identifier),
     responseValue: () => null,
+    variableDefault: (identifier) => {
+      const declaration = declarationsById.get(identifier) ?? responseDeclarationsById.get(identifier);
+      if (!declaration?.defaultValue) {
+        return null;
+      }
+      return rpValue(declaration.cardinality, declaration.defaultValue.values.map((entry) => coerceScalar(entry.value, declaration.baseType)), declaration.baseType);
+    },
     random: mulberry32(context.seed),
     customOperators: context.customOperators
   };
@@ -1863,6 +2873,22 @@ function executeTemplateProcessing(view, context) {
     issues
   };
 }
+function applyTemplateDefaultOverrides(declarations, overrides) {
+  return declarations.map((declaration) => {
+    if (!(declaration.identifier in overrides)) {
+      return declaration;
+    }
+    const value = overrides[declaration.identifier];
+    if (value === null || value === undefined) {
+      const { defaultValue: _cleared, ...rest } = declaration;
+      return rest;
+    }
+    return {
+      ...declaration,
+      defaultValue: { values: (Array.isArray(value) ? value : [value]).map((member) => ({ value: member })) }
+    };
+  });
+}
 function applyCorrectResponseOverrides(declarations, overrides) {
   return declarations.map((declaration) => {
     const override = overrides[declaration.identifier];
@@ -1904,11 +2930,98 @@ function collectTemplateIssues(view, options) {
   walkRules(view.rules);
   return issues;
 }
+// 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: options.templateDeclarations ?? [],
+    templateDeclarations,
     responseDeclarations: declarations,
     seed,
     customOperators: options.customOperators
@@ -1918,13 +3031,30 @@ function createAttemptStore(declarations, initialResponses, options) {
   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: {},
+    outcomes: maintainedOutcomes(),
     templateValues: templateResult?.templateValues ?? {},
-    attemptCount: 0
+    attemptCount: 0,
+    durationSeconds: null,
+    responseViolations: violationsOf(initialResponses),
+    correctResponses
   };
   function emit(next) {
     snapshot = next;
@@ -1935,7 +3065,7 @@ function createAttemptStore(declarations, initialResponses, options) {
   function computeScores(responses) {
     return [...declarationsById.values()].map((declaration) => scoreResponse(declaration, responses[declaration.identifier] ?? null, options?.normalization));
   }
-  function computeOutcomes(responses, priorOutcomes) {
+  function computeOutcomes(responses, durationSeconds, priorOutcomes) {
     if (!options?.responseProcessing) {
       return {};
     }
@@ -1944,11 +3074,14 @@ function createAttemptStore(declarations, initialResponses, options) {
       outcomeDeclarations: options.outcomeDeclarations ?? [],
       responses,
       normalization: options.normalization,
-      templateDeclarations: options.templateDeclarations,
+      templateDeclarations,
       templateValues: snapshot.templateValues,
       priorOutcomes,
       random: rpRandom,
-      customOperators: options.customOperators
+      customOperators: options.customOperators,
+      duration: durationSeconds,
+      numAttempts: snapshot.attemptCount + 1,
+      ...typeof snapshot.outcomes["completionStatus"] === "string" ? { completionStatus: snapshot.outcomes["completionStatus"] } : {}
     }).outcomes;
   }
   return {
@@ -1963,9 +3096,11 @@ function createAttemptStore(declarations, initialResponses, options) {
       if (snapshot.submitted) {
         return;
       }
+      const responses = { ...snapshot.responses, [responseIdentifier]: value };
       emit({
         ...snapshot,
-        responses: { ...snapshot.responses, [responseIdentifier]: value }
+        responses,
+        responseViolations: violationsOf(responses)
       });
     },
     registerResponseCollector: (responseIdentifier, collector) => {
@@ -1988,11 +3123,17 @@ function createAttemptStore(declarations, initialResponses, options) {
         }
       }
       if (collected !== snapshot.responses) {
-        snapshot = { ...snapshot, responses: collected };
+        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 outcomes = computeOutcomes(snapshot.responses, priorOutcomes);
+      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;
@@ -2010,27 +3151,200 @@ function createAttemptStore(declarations, initialResponses, options) {
         submitted: completed,
         scores,
         outcomes,
-        attemptCount: snapshot.attemptCount + 1
+        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: {},
+        outcomes: maintainedOutcomes(),
         templateValues: snapshot.templateValues,
-        attemptCount: 0
+        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", "exitTest"]);
+var supportedOutcomeRuleKinds = new Set([
+  "outcomeCondition",
+  "setOutcomeValue",
+  "lookupOutcomeValue",
+  "outcomeProcessingFragment",
+  "exitTest"
+]);
 var testExpressionKinds = new Set([
   ...deterministicExpressionKinds,
   "testVariables",
+  "outcomeMinimum",
+  "outcomeMaximum",
   "numberCorrect",
   "numberIncorrect",
   "numberPresented",
@@ -2071,54 +3385,83 @@ 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]];
+  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((a, b) => a - b).map((index) => pool[index]);
+  return indices.slice(0, Math.min(count, indices.length)).sort((a3, b2) => a3 - b2).map((index) => pool[index]);
 }
-function applySelection(children, select, random) {
+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 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);
+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 i = shuffled.length - 1;i > 0; i -= 1) {
-    const j = Math.floor(random() * (i + 1));
-    [shuffled[i], shuffled[j]] = [shuffled[j], shuffled[i]];
+  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 resolveSection(section, partIdentifier, sectionPath, inheritedPreConditions, inheritedControl, random) {
+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.select, random);
+    children = applySelection(children, section.selection, random);
   }
+  let units = children.map((child) => ({ child, via: [] }));
   if (section.ordering?.shuffle) {
-    children = applyOrdering(children, random);
+    units = applyOrdering(mixedUnits(children, random, sections), random);
   }
   const items = [];
-  for (const child of children) {
+  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, path, preConditions, control, random));
+      items.push(...resolveSection(child, partIdentifier, viaPath, viaPreConditions, viaControl, random, sections));
     } else {
       items.push({
         key: child.identifier,
         ref: child,
         partIdentifier,
-        sectionPath: path,
-        preConditions: [...preConditions, ...child.preConditions ?? []],
-        sessionControl: { ...specSessionControlDefaults, ...control, ...definedControl(child.itemSessionControl) },
+        sectionPath: viaPath,
+        preConditions: [...viaPreConditions, ...child.preConditions ?? []],
+        sessionControl: { ...specSessionControlDefaults, ...viaControl, ...definedControl(child.itemSessionControl) },
         ...child.timeLimits ? { timeLimits: child.timeLimits } : {}
       });
     }
@@ -2127,15 +3470,36 @@ function resolveSection(section, partIdentifier, sectionPath, inheritedPreCondit
 }
 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: 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))
-    }))
+    parts: keyedParts,
+    sections
   };
 }
 function createTestController(view, options) {
@@ -2143,10 +3507,17 @@ function createTestController(view, options) {
   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) {
@@ -2167,13 +3538,123 @@ function createTestController(view, options) {
       return !(excludeCategory !== undefined && excludeCategory.some((category) => categories.includes(category)));
     });
   }
-  function remainingAttempts(state, itemKey) {
-    const item = itemsByKey.get(itemKey);
-    if (!item) {
+  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;
     }
-    const max = item.sessionControl.maxAttempts;
-    return max === 0 ? Number.POSITIVE_INFINITY : Math.max(0, max - attemptsOf(state, itemKey));
+    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;
@@ -2186,13 +3667,56 @@ function createTestController(view, options) {
     }
     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) {
-          const itemKey = identifier.slice(0, dot);
-          const variableName = identifier.slice(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)) {
@@ -2219,9 +3743,8 @@ function createTestController(view, options) {
             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));
+            members.push(...lifted.values.map((entry) => Number(entry) * weightOf(item, weightIdentifier)));
             continue;
           }
           baseType ??= lifted.baseType;
@@ -2251,6 +3774,22 @@ function createTestController(view, options) {
             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);
         }
@@ -2294,6 +3833,20 @@ function createTestController(view, options) {
           }
           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;
         }
@@ -2315,11 +3868,11 @@ function createTestController(view, options) {
     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)) {
+    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;
         }
       }
@@ -2352,6 +3905,21 @@ function createTestController(view, options) {
   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);
@@ -2360,6 +3928,7 @@ function createTestController(view, options) {
     }
     const itemOutcomes = { ...state.itemOutcomes };
     const attemptCounts = { ...state.attemptCounts ?? {} };
+    const itemDurations = { ...state.itemDurationSeconds ?? {} };
     const remaining = { ...pending };
     let flagged = state;
     for (const key of keys) {
@@ -2367,14 +3936,56 @@ function createTestController(view, options) {
       itemOutcomes[key] = result.outcomes;
       attemptCounts[key] = (attemptCounts[key] ?? 0) + 1;
       delete remaining[key];
-      flagged = applyResultFlags(flagged, key, result);
+      if (result.durationSeconds !== undefined) {
+        itemDurations[key] = result.durationSeconds;
+      }
+      flagged = withRecordedAttempt(applyResultFlags(flagged, key, result), key, result, result.submittedAtMs ?? now());
     }
-    return { ...flagged, itemOutcomes, attemptCounts, pendingItemResults: remaining };
+    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);
@@ -2388,10 +3999,14 @@ function createTestController(view, options) {
         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 === "ended" || state.currentItemKey === null) {
+    if (state.status !== "in-progress" || state.currentItemKey === null) {
       return state;
     }
     const current = positionOf(state.currentItemKey);
@@ -2403,6 +4018,9 @@ function createTestController(view, options) {
     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;
@@ -2422,20 +4040,84 @@ function createTestController(view, options) {
         }
         return moveToItem(state, firstNavigable(state, current.partIndex, index));
       }
-      const target = positionOf(branchRule.target);
+      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));
+      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) {
@@ -2450,9 +4132,18 @@ function createTestController(view, options) {
         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);
@@ -2472,8 +4163,12 @@ function createTestController(view, options) {
     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: () => {
@@ -2488,13 +4183,21 @@ function createTestController(view, options) {
         correctItems: [],
         incorrectItems: [],
         pendingItemResults: {},
-        testOutcomes: {}
+        testOutcomes: {},
+        timing: {
+          lastTransitionAtMs: now(),
+          testSeconds: 0,
+          partSeconds: {},
+          sectionSeconds: {},
+          itemSeconds: {}
+        }
       };
-      return moveToItem({ ...initial, testOutcomes: runOutcomeProcessing(initial) }, firstNavigable(initial, 0, 0));
+      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 === "ended" || state.currentItemKey === null) {
+      if (state.status !== "in-progress" || state.currentItemKey === null) {
         return false;
       }
       const current = positionOf(state.currentItemKey);
@@ -2505,47 +4208,65 @@ function createTestController(view, options) {
       if (plan.parts[current.partIndex].navigationMode !== "nonlinear") {
         return false;
       }
-      return preConditionsPass(plan.parts[target.partIndex].items[target.itemIndex], state);
+      const item = plan.parts[target.partIndex].items[target.itemIndex];
+      return preConditionsPass(item, state) && navigableInTime(state, item) && !reviewBarred(state, item);
     },
-    moveTo: (state, itemKey) => {
-      const current = positionOf(state.currentItemKey ?? "");
+    moveTo: (state, itemKey) => withTransition(state, (settled) => {
+      const current = positionOf(settled.currentItemKey ?? "");
       const target = positionOf(itemKey);
-      if (state.status === "ended" || !current || !target || target.partIndex !== current.partIndex || plan.parts[current.partIndex].navigationMode !== "nonlinear") {
-        return state;
+      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({ ...state, currentItemKey: itemKey }, itemKey);
-    },
+      return markPresented({ ...settled, currentItemKey: itemKey }, itemKey);
+    }),
     canNext: (state) => nextState(state) !== state,
-    next: nextState,
+    next: (state) => withTransition(state, nextState),
     remainingAttempts,
-    canSubmitItem: (state, itemKey) => state.status !== "ended" && remainingAttempts(state, itemKey) > 0,
+    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) => {
-      if (state.status === "ended") {
+      const item = itemsByKey.get(itemKey);
+      if (state.status !== "in-progress" || !item) {
         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]
-        };
+      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 }
+          ]
+        });
       }
-      if (result.adaptive !== true && remainingAttempts(state, itemKey) <= 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 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) };
+      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() } } : {}
     },
-    end: (state) => state.status === "ended" ? state : ended(state),
+    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) {
@@ -2557,6 +4278,187 @@ function createTestController(view, options) {
     })
   };
 }
+// 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 ?? []) {
@@ -2623,9 +4525,22 @@ function createTestSessionStore(controller, options) {
       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();
     }
@@ -2642,11 +4557,15 @@ function createTestSessionStore(controller, options) {
       return itemStores.get(itemKey) ?? null;
     }
     const view = itemView(itemKey);
-    if (!view) {
+    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,
@@ -2654,8 +4573,13 @@ function createTestSessionStore(controller, options) {
       adaptive: view.adaptive,
       seed: deriveItemSeed(options.seed, itemKey),
       normalization: options.normalization,
-      customOperators: options.customOperators
+      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();
@@ -2664,7 +4588,10 @@ function createTestSessionStore(controller, options) {
         const next = controller.submitItem(state, itemKey, {
           outcomes: attempt.outcomes,
           ...resultFlags(attempt, scorable),
-          ...view.adaptive === true ? { adaptive: true } : {}
+          ...view.adaptive === true ? { adaptive: true } : {},
+          ...attempt.durationSeconds !== null ? { durationSeconds: attempt.durationSeconds } : {},
+          valid: attempt.responseViolations.length === 0,
+          responses: attempt.responses
         });
         if (next !== state) {
           emit(next);
@@ -2686,7 +4613,31 @@ function createTestSessionStore(controller, options) {
     next: () => emit(controller.next(state)),
     canMoveTo: (itemKey) => controller.canMoveTo(state, itemKey),
     moveTo: (itemKey) => emit(controller.moveTo(state, itemKey)),
-    end: () => emit(controller.end(state))
+    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/runtime.ts
@@ -2741,7 +4692,10 @@ function createStaticStore(outcomes) {
     scores: [],
     outcomes,
     templateValues: {},
-    attemptCount: 1
+    attemptCount: 1,
+    durationSeconds: null,
+    responseViolations: [],
+    correctResponses: {}
   };
   return {
     getSnapshot: () => snapshot,
@@ -2749,7 +4703,9 @@ function createStaticStore(outcomes) {
     setResponse: () => {},
     registerResponseCollector: () => () => {},
     submit: () => [],
-    reset: () => {}
+    reset: () => {},
+    suspend: () => {},
+    resume: () => {}
   };
 }
 function feedbackVisible(outcome, feedback, submitted) {
@@ -2763,7 +4719,11 @@ 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);
+  const ssmlNamespace = "http://www.w3.org/2001/10/synthesis";
   function renderFlow(node, key, overrides, inMath = false) {
+    if (node.namespace === ssmlNamespace) {
+      return createElement(Fragment, { key }, node.value ?? node.children?.map((child, index) => renderNode(child, index, overrides, inMath)));
+    }
     const isMath = inMath || node.name === model.mathRoot;
     if (!isMath && !isAllowedFlowElement(model, node.name)) {
       return null;
@@ -2784,7 +4744,40 @@ function createQtiRuntime(config) {
     }
     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) {
+  function catalogIdrefOf(node) {
+    const value = node.kind === "xml" ? node.attributes?.["data-catalog-idref"] : node.dataCatalogIdref;
+    return typeof value === "string" && value !== "" ? value : undefined;
+  }
+  function renderSupportDefault(support, catalogIdref, key, overrides) {
+    return createElement("span", {
+      key: `support-${key}`,
+      role: "note",
+      "data-qti-catalog-idref": catalogIdref,
+      "data-qti-support": support.support,
+      ...support.xmlLang !== undefined ? { lang: support.xmlLang } : {}
+    }, support.content?.map((child, index) => renderNode(child, index, overrides)), support.fileHrefs?.map((file, index) => createElement("a", { key: `file-${index}`, href: resolveAsset(file.href), type: file.mimeType, "data-qti-support-file": true }, support.support)));
+  }
+  function CatalogSupportHost({
+    catalogIdref,
+    node,
+    overrides,
+    inMath
+  }) {
+    const { catalogSupports } = useRuntimeContext();
+    const supports = catalogSupports.get(catalogIdref) ?? [];
+    const original = renderNode(node, 0, overrides, inMath, true);
+    if (!supports.length) {
+      return original;
+    }
+    return createElement(Fragment, null, original, supports.map((support, index) => config.renderCatalogSupport ? createElement(Fragment, { key: `support-${index}` }, config.renderCatalogSupport(support, catalogIdref)) : renderSupportDefault(support, catalogIdref, index, overrides)));
+  }
+  function renderNode(node, key, overrides, inMath = false, skipCatalog = false) {
+    if (!skipCatalog) {
+      const catalogIdref = catalogIdrefOf(node);
+      if (catalogIdref !== undefined) {
+        return createElement(CatalogSupportHost, { key, catalogIdref, node, overrides, inMath });
+      }
+    }
     const override = overrides?.[node.kind];
     if (override) {
       return createElement(Fragment, { key }, override(node, key));
@@ -2836,10 +4829,10 @@ function createQtiRuntime(config) {
     element,
     overrides
   }) {
-    const { store } = useRuntimeContext();
+    const { store, suppressFeedback, defaultOutcomes: defaultOutcomes2 } = useRuntimeContext();
     const snapshot = useSyncExternalStore(store.subscribe, store.getSnapshot, store.getSnapshot);
-    const outcome = snapshot.outcomes[feedback.outcomeIdentifier] ?? null;
-    if (!feedbackVisible(outcome, feedback, snapshot.submitted)) {
+    const outcome = suppressFeedback ? defaultOutcomes2[feedback.outcomeIdentifier] ?? null : snapshot.outcomes[feedback.outcomeIdentifier] ?? null;
+    if (!feedbackVisible(outcome, feedback, suppressFeedback || snapshot.submitted)) {
       return null;
     }
     return createElement(element, { "data-qti-feedback": feedback.identifier }, feedback.content?.map((child, index) => renderNode(child, index, overrides)));
@@ -2865,35 +4858,39 @@ function createQtiRuntime(config) {
     return createElement("span", { "data-qti-printed-variable": identifier }, text);
   }
   function ModalFeedbackHost({ feedback }) {
-    const { store } = useRuntimeContext();
+    const { store, suppressFeedback } = useRuntimeContext();
     const snapshot = useSyncExternalStore(store.subscribe, store.getSnapshot, store.getSnapshot);
     const outcome = snapshot.outcomes[feedback.outcomeIdentifier] ?? null;
-    if (!feedbackVisible(outcome, feedback, snapshot.submitted)) {
+    if (suppressFeedback || !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 { store, declarationsById, mode, suppressFeedback, solutionResponses } = 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 value = mode === "solution" ? solutionResponses[responseIdentifier] ?? null : snapshot.responses[responseIdentifier] ?? null;
+    const disabled = snapshot.submitted || mode !== "interact";
+    const revealed = mode === "solution" || snapshot.submitted && !suppressFeedback;
     const answered = value !== null && !(typeof value === "string" && value.trim() === "") && !(Array.isArray(value) && value.length === 0);
     let status = answered ? "answered" : "unanswered";
-    if (disabled) {
+    if (revealed) {
       const scored = snapshot.scores.find((score) => score.identifier === responseIdentifier);
-      status = scored?.correct ? "correct" : "incorrect";
+      status = mode === "solution" || scored?.correct ? "correct" : "incorrect";
     }
     const setValue = (next) => {
+      if (disabled) {
+        return;
+      }
       store.setResponse(responseIdentifier, next);
     };
     const getOptionProps = (optionIdentifier) => {
       const selected = responseIncludes(value, optionIdentifier);
       let status2 = selected ? "selected" : "idle";
-      if (disabled) {
+      if (revealed) {
         if (isCorrectOption(declaration, optionIdentifier)) {
           status2 = "correct";
         } else if (selected) {
@@ -2923,6 +4920,14 @@ function createQtiRuntime(config) {
       };
     };
     const renderContent = (nodes, overrides) => nodes ? nodes.map((child, index) => renderNode(child, index, overrides)) : null;
+    const { catalogSupports } = useRuntimeContext();
+    const renderCatalogSupportsForSkin = (catalogIdref) => {
+      const supports = catalogIdref !== undefined ? catalogSupports.get(catalogIdref) ?? [] : [];
+      if (!supports.length) {
+        return null;
+      }
+      return supports.map((support, index) => config.renderCatalogSupport ? createElement(Fragment, { key: `support-${index}` }, config.renderCatalogSupport(support, catalogIdref)) : renderSupportDefault(support, catalogIdref, index));
+    };
     const Skin = config.skin[node.kind];
     if (!Skin) {
       return null;
@@ -2932,8 +4937,9 @@ function createQtiRuntime(config) {
       responseIdentifier,
       value,
       setValue,
+      renderCatalogSupports: renderCatalogSupportsForSkin,
       disabled,
-      showFeedback: disabled,
+      showFeedback: revealed,
       status,
       getOptionProps,
       renderContent,
@@ -2945,12 +4951,32 @@ function createQtiRuntime(config) {
       registerResponseCollector: (collector) => store.registerResponseCollector(responseIdentifier, collector)
     });
   }
-  function ContentRenderer({ nodes, outcomes }) {
+  function ContentRenderer({ nodes, outcomes, catalogs, pnp, activeSupports }) {
     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 catalogSupports = useMemo(() => resolveCatalogSupports({ catalogs, pnp, activeSupports }).byCatalogId, [catalogs, pnp, activeSupports]);
+    return createElement(RuntimeContext.Provider, {
+      value: {
+        store,
+        declarationsById,
+        mode: "interact",
+        suppressFeedback: false,
+        solutionResponses: {},
+        defaultOutcomes: {},
+        catalogSupports
+      }
+    }, nodes?.map((node, index) => renderNode(node, index)));
+  }
+  function ItemRenderer({
+    item,
+    store: externalStore,
+    seed,
+    mode = "interact",
+    showFeedback,
+    pnp,
+    activeSupports,
+    children
+  }) {
     const store = useMemo(() => externalStore ?? createAttemptStore(item.responseDeclarations, {}, {
       outcomeDeclarations: item.outcomeDeclarations,
       responseProcessing: item.responseProcessing,
@@ -2959,12 +4985,44 @@ function createQtiRuntime(config) {
       adaptive: item.adaptive,
       seed,
       normalization: config.normalization,
-      customOperators: config.customOperators
+      customOperators: config.customOperators,
+      constraints: collectInteractionConstraints(item.itemBody.content)
     }), [item, externalStore, seed]);
     const declarationsById = useMemo(() => new Map(item.responseDeclarations.map((declaration) => [declaration.identifier, declaration])), [item]);
+    const suppressFeedback = mode !== "interact" && showFeedback === false && item.adaptive !== true;
+    const defaultOutcomes2 = useMemo(() => {
+      const defaults = {};
+      for (const declaration of item.outcomeDeclarations ?? []) {
+        const values = declaration.defaultValue?.values;
+        if (values !== undefined) {
+          defaults[declaration.identifier] = declaration.cardinality === "single" ? values[0]?.value ?? null : values.map((entry) => entry.value);
+        }
+      }
+      return defaults;
+    }, [item]);
+    const stimulusViews = (item.assessmentStimulusRefs ?? []).map((ref) => ({
+      ref,
+      view: config.resolveStimulus?.(ref) ?? null
+    }));
+    const catalogSupports = resolveCatalogSupports({
+      catalogs: [...item.catalogs ?? [], ...stimulusViews.flatMap(({ view }) => view?.catalogs ?? [])],
+      pnp,
+      activeSupports
+    }).byCatalogId;
+    const stimuli = stimulusViews.map(({ ref, view }, index) => createElement("section", { key: `stimulus-${index}`, "data-qti-stimulus": ref.identifier }, view === null ? createElement("div", { role: "note", "data-qti-unsupported": "assessmentStimulusRef" }, `This content requires a shared stimulus (${ref.href}) this runtime cannot resolve.`) : view.content.map((node, nodeIndex) => renderNode(node, nodeIndex))));
     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);
+    return createElement(RuntimeContext.Provider, {
+      value: {
+        store,
+        declarationsById,
+        mode,
+        suppressFeedback,
+        solutionResponses: store.getSnapshot().correctResponses,
+        defaultOutcomes: defaultOutcomes2,
+        catalogSupports
+      }
+    }, stimuli, body, modals, children);
   }
   function useAttempt() {
     const { store } = useRuntimeContext();
@@ -2975,6 +5033,11 @@ function createQtiRuntime(config) {
       reset: store.reset
     };
   }
+  const noSupports = [];
+  function useCatalogSupports(catalogIdref) {
+    const { catalogSupports } = useRuntimeContext();
+    return catalogIdref !== undefined ? catalogSupports.get(catalogIdref) ?? noSupports : noSupports;
+  }
   function canDeliver(item) {
     const issues = [];
     const seen = new Set;
@@ -3035,13 +5098,26 @@ function createQtiRuntime(config) {
     for (const node of item.itemBody.content ?? []) {
       walk(node);
     }
+    for (const ref of item.assessmentStimulusRefs ?? []) {
+      const stimulus = config.resolveStimulus?.(ref) ?? null;
+      if (stimulus === null) {
+        report({ type: "unsupported-element", name: "assessmentStimulusRef", detail: ref.href });
+        continue;
+      }
+      for (const node of stimulus.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 })) {
+    for (const issue of collectRpIssues(item.responseProcessing, {
+      customOperatorClasses,
+      outcomeDeclarations: item.outcomeDeclarations ?? []
+    })) {
       report(issue);
     }
     for (const issue of collectTemplateIssues(item.templateProcessing, { customOperatorClasses })) {
@@ -3049,7 +5125,7 @@ function createQtiRuntime(config) {
     }
     return { deliverable: issues.length === 0, issues };
   }
-  return { ItemRenderer, ContentRenderer, useAttempt, canDeliver };
+  return { ItemRenderer, ContentRenderer, useAttempt, useCatalogSupports, canDeliver };
 }
 // src/pci/response.ts
 function scalarToString(value) {
@@ -3389,23 +5465,23 @@ async function mountPci(options) {
   };
 }
 // 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()
+import { z as z2 } from "zod";
+var interactionModuleSchema = z2.object({
+  id: z2.string().min(1),
+  primaryPath: z2.string().optional(),
+  fallbackPath: z2.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()
+var pciNodeSchema = z2.object({
+  kind: z2.literal("portableCustomInteraction"),
+  responseIdentifier: z2.string().min(1),
+  customInteractionTypeIdentifier: z2.string().min(1),
+  module: z2.string().optional(),
+  properties: z2.record(z2.string(), z2.string()).optional(),
+  interactionMarkup: z2.object({ content: z2.array(z2.unknown()).optional() }).optional(),
+  interactionModules: z2.object({
+    primaryConfiguration: z2.string().optional(),
+    secondaryConfiguration: z2.string().optional(),
+    modules: z2.array(interactionModuleSchema).optional()
   }).optional()
 });
 var portableCustomInteraction = defineInteraction({
@@ -3465,12 +5541,12 @@ function createPciSkin(options) {
   };
 }
 // 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()
+import { z as z3 } from "zod";
+var associateInteractionNodeSchema = z3.object({
+  kind: z3.literal("associateInteraction"),
+  responseIdentifier: z3.string().min(1),
+  simpleAssociableChoices: z3.array(z3.looseObject({ identifier: z3.string().min(1), matchMax: z3.number().int().optional() })).min(2),
+  maxAssociations: z3.number().int().optional()
 });
 var associateInteraction = defineInteraction({
   kind: "associateInteraction",
@@ -3482,12 +5558,12 @@ var associateInteraction = defineInteraction({
 });
 
 // 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()
+import { z as z4 } from "zod";
+var choiceInteractionNodeSchema = z4.object({
+  kind: z4.literal("choiceInteraction"),
+  responseIdentifier: z4.string().min(1),
+  simpleChoices: z4.array(z4.object({ identifier: z4.string().min(1) })).min(1),
+  maxChoices: z4.number().int().optional()
 });
 var choiceInteraction = defineInteraction({
   kind: "choiceInteraction",
@@ -3499,15 +5575,15 @@ var choiceInteraction = defineInteraction({
 });
 
 // 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()
+import { z as z5 } from "zod";
+var drawingInteractionNodeSchema = z5.object({
+  kind: z5.literal("drawingInteraction"),
+  responseIdentifier: z5.string().min(1),
+  object: z5.object({
+    data: z5.string().min(1),
+    width: z5.number().optional(),
+    height: z5.number().optional(),
+    type: z5.string().optional()
   })
 });
 var drawingInteraction = defineInteraction({
@@ -3520,11 +5596,11 @@ var drawingInteraction = defineInteraction({
 });
 
 // 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)
+import { z as z6 } from "zod";
+var endAttemptInteractionNodeSchema = z6.object({
+  kind: z6.literal("endAttemptInteraction"),
+  responseIdentifier: z6.string().min(1),
+  title: z6.string().min(1)
 });
 var endAttemptInteraction = defineInteraction({
   kind: "endAttemptInteraction",
@@ -3536,13 +5612,13 @@ var endAttemptInteraction = defineInteraction({
 });
 
 // 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()
+import { z as z7 } from "zod";
+var extendedTextInteractionNodeSchema = z7.object({
+  kind: z7.literal("extendedTextInteraction"),
+  responseIdentifier: z7.string().min(1),
+  expectedLength: z7.number().int().optional(),
+  expectedLines: z7.number().int().optional(),
+  placeholderText: z7.string().optional()
 });
 var extendedTextInteraction = defineInteraction({
   kind: "extendedTextInteraction",
@@ -3554,12 +5630,12 @@ var extendedTextInteraction = defineInteraction({
 });
 
 // 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)
+import { z as z8 } from "zod";
+var gapMatchInteractionNodeSchema = z8.object({
+  kind: z8.literal("gapMatchInteraction"),
+  responseIdentifier: z8.string().min(1),
+  gapTexts: z8.array(z8.looseObject({ identifier: z8.string().min(1), matchMax: z8.number().int().optional() })).min(1),
+  content: z8.array(z8.looseObject({ kind: z8.string().min(1) })).min(1)
 });
 var gapMatchInteraction = defineInteraction({
   kind: "gapMatchInteraction",
@@ -3571,99 +5647,99 @@ var gapMatchInteraction = defineInteraction({
 });
 
 // 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()
+import { z as z9 } from "zod";
+var objectSchema = z9.object({
+  data: z9.string().min(1),
+  width: z9.number().optional(),
+  height: z9.number().optional(),
+  type: z9.string().optional()
 });
-var hotspotSchema = z8.looseObject({
-  identifier: z8.string().min(1),
-  shape: z8.string().min(1),
-  coords: z8.array(z8.number())
+var hotspotSchema = z9.looseObject({
+  identifier: z9.string().min(1),
+  shape: z9.string().min(1),
+  coords: z9.array(z9.number())
 });
 function nullInitial() {
   return null;
 }
 var hotspotInteraction = defineInteraction({
   kind: "hotspotInteraction",
-  schema: z8.object({
-    kind: z8.literal("hotspotInteraction"),
-    responseIdentifier: z8.string().min(1),
+  schema: z9.object({
+    kind: z9.literal("hotspotInteraction"),
+    responseIdentifier: z9.string().min(1),
     object: objectSchema,
-    hotspotChoices: z8.array(hotspotSchema).min(1),
-    maxChoices: z8.number().int().optional()
+    hotspotChoices: z9.array(hotspotSchema).min(1),
+    maxChoices: z9.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),
+  schema: z9.object({
+    kind: z9.literal("graphicOrderInteraction"),
+    responseIdentifier: z9.string().min(1),
     object: objectSchema,
-    hotspotChoices: z8.array(hotspotSchema).min(1)
+    hotspotChoices: z9.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),
+  schema: z9.object({
+    kind: z9.literal("graphicAssociateInteraction"),
+    responseIdentifier: z9.string().min(1),
     object: objectSchema,
-    associableHotspots: z8.array(hotspotSchema).min(2),
-    maxAssociations: z8.number().int().optional()
+    associableHotspots: z9.array(hotspotSchema).min(2),
+    maxAssociations: z9.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),
+  schema: z9.object({
+    kind: z9.literal("graphicGapMatchInteraction"),
+    responseIdentifier: z9.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)
+    gapImgs: z9.array(z9.looseObject({ identifier: z9.string().min(1), object: objectSchema.optional() })).min(1),
+    associableHotspots: z9.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),
+  schema: z9.object({
+    kind: z9.literal("selectPointInteraction"),
+    responseIdentifier: z9.string().min(1),
     object: objectSchema,
-    maxChoices: z8.number().int().optional()
+    maxChoices: z9.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),
+  schema: z9.object({
+    kind: z9.literal("positionObjectStage"),
+    responseIdentifier: z9.string().min(1),
     stageObject: objectSchema,
     object: objectSchema,
-    maxChoices: z8.number().int().optional()
+    maxChoices: z9.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)
+import { z as z10 } from "zod";
+var hottextInteractionNodeSchema = z10.object({
+  kind: z10.literal("hottextInteraction"),
+  responseIdentifier: z10.string().min(1),
+  maxChoices: z10.number().int().optional(),
+  content: z10.array(z10.looseObject({ kind: z10.string().min(1) })).min(1)
 });
 var hottextInteraction = defineInteraction({
   kind: "hottextInteraction",
@@ -3675,11 +5751,11 @@ var hottextInteraction = defineInteraction({
 });
 
 // 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)
+import { z as z11 } from "zod";
+var inlineChoiceInteractionNodeSchema = z11.object({
+  kind: z11.literal("inlineChoiceInteraction"),
+  responseIdentifier: z11.string().min(1),
+  inlineChoices: z11.array(z11.object({ identifier: z11.string().min(1) })).min(1)
 });
 var inlineChoiceInteraction = defineInteraction({
   kind: "inlineChoiceInteraction",
@@ -3691,15 +5767,15 @@ var inlineChoiceInteraction = defineInteraction({
 });
 
 // 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)
+import { z as z12 } from "zod";
+var simpleMatchSetSchema = z12.object({
+  simpleAssociableChoices: z12.array(z12.looseObject({ identifier: z12.string().min(1), matchMax: z12.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 matchInteractionNodeSchema = z12.object({
+  kind: z12.literal("matchInteraction"),
+  responseIdentifier: z12.string().min(1),
+  simpleMatchSets: z12.array(simpleMatchSetSchema).length(2),
+  maxAssociations: z12.number().int().optional()
 });
 var matchInteraction = defineInteraction({
   kind: "matchInteraction",
@@ -3711,15 +5787,15 @@ var matchInteraction = defineInteraction({
 });
 
 // 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)
+import { z as z13 } from "zod";
+var mediaInteractionNodeSchema = z13.object({
+  kind: z13.literal("mediaInteraction"),
+  responseIdentifier: z13.string().min(1),
+  autostart: z13.boolean().optional(),
+  minPlays: z13.number().int().optional(),
+  maxPlays: z13.number().int().optional(),
+  loop: z13.boolean().optional(),
+  content: z13.array(z13.looseObject({ kind: z13.string().min(1) })).min(1)
 });
 var mediaInteraction = defineInteraction({
   kind: "mediaInteraction",
@@ -3731,13 +5807,13 @@ var mediaInteraction = defineInteraction({
 });
 
 // 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()
+import { z as z14 } from "zod";
+var orderInteractionNodeSchema = z14.object({
+  kind: z14.literal("orderInteraction"),
+  responseIdentifier: z14.string().min(1),
+  simpleChoices: z14.array(z14.looseObject({ identifier: z14.string().min(1) })).min(1),
+  shuffle: z14.boolean().optional(),
+  orientation: z14.enum(["horizontal", "vertical"]).optional()
 });
 var orderInteraction = defineInteraction({
   kind: "orderInteraction",
@@ -3749,16 +5825,16 @@ var orderInteraction = defineInteraction({
 });
 
 // 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()
+import { z as z15 } from "zod";
+var sliderInteractionNodeSchema = z15.object({
+  kind: z15.literal("sliderInteraction"),
+  responseIdentifier: z15.string().min(1),
+  lowerBound: z15.number(),
+  upperBound: z15.number(),
+  step: z15.number().optional(),
+  stepLabel: z15.boolean().optional(),
+  orientation: z15.enum(["horizontal", "vertical"]).optional(),
+  reverse: z15.boolean().optional()
 });
 var sliderInteraction = defineInteraction({
   kind: "sliderInteraction",
@@ -3770,13 +5846,13 @@ var sliderInteraction = defineInteraction({
 });
 
 // src/interactions/text-entry.ts
-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()
+import { z as z16 } from "zod";
+var textEntryInteractionNodeSchema = z16.object({
+  kind: z16.literal("textEntryInteraction"),
+  responseIdentifier: z16.string().min(1),
+  expectedLength: z16.number().int().optional(),
+  placeholderText: z16.string().optional(),
+  patternMask: z16.string().optional()
 });
 var textEntryInteraction = defineInteraction({
   kind: "textEntryInteraction",
@@ -3788,11 +5864,11 @@ 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()
+import { z as z17 } from "zod";
+var uploadInteractionNodeSchema = z17.object({
+  kind: z17.literal("uploadInteraction"),
+  responseIdentifier: z17.string().min(1),
+  type: z17.string().optional()
 });
 var uploadInteraction = defineInteraction({
   kind: "uploadInteraction",
@@ -3879,8 +5955,8 @@ function AssociateReferenceSkin(props) {
     }, 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", {
+    const [a3, b2] = pair.split(/\s+/u);
+    return createElement3("li", { key: pair, "data-qti-pair": pair }, `${labelFor(a3 ?? "")} ↔ ${labelFor(b2 ?? "")} `, createElement3("button", {
       type: "button",
       disabled: props.disabled,
       "aria-label": `Remove pair ${pair}`,
@@ -3901,7 +5977,7 @@ function ChoiceReferenceSkin(props) {
     "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);
+    return createElement4("button", { key: choice.identifier, type: "button", disabled: props.disabled, ...optionProps }, props.renderContent(choice.content) ?? choice.identifier, props.renderCatalogSupports(choice.dataCatalogIdref));
   }));
 }
 
@@ -3958,12 +6034,12 @@ function DrawingReferenceSkin(props) {
     }
     drawingRef.current = true;
     event.currentTarget.setPointerCapture(event.pointerId);
-    const { x, y } = pointerPosition(event);
+    const { x: x2, y: y2 } = pointerPosition(event);
     context.strokeStyle = strokeStyle;
     context.lineWidth = strokeWidth;
     context.lineCap = "round";
     context.beginPath();
-    context.moveTo(x, y);
+    context.moveTo(x2, y2);
   };
   const handlePointerMove = (event) => {
     if (!drawingRef.current) {
@@ -3973,8 +6049,8 @@ function DrawingReferenceSkin(props) {
     if (!context) {
       return;
     }
-    const { x, y } = pointerPosition(event);
-    context.lineTo(x, y);
+    const { x: x2, y: y2 } = pointerPosition(event);
+    context.lineTo(x2, y2);
     context.stroke();
   };
   const handlePointerUp = (event) => {
@@ -4075,14 +6151,14 @@ function shapeCenter(shape, coords) {
     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;
+      let x2 = 0;
+      let y2 = 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;
+      for (let i3 = 0;i3 < pointCount * 2; i3 += 2) {
+        x2 += coords[i3] ?? 0;
+        y2 += coords[i3 + 1] ?? 0;
       }
-      return pointCount === 0 ? { x: 0, y: 0 } : { x: x / pointCount, y: y / pointCount };
+      return pointCount === 0 ? { x: 0, y: 0 } : { x: x2 / pointCount, y: y2 / pointCount };
     }
     default:
       return { x: 0, y: 0 };
@@ -4105,8 +6181,8 @@ function shapeElement(shape, coords, key, props) {
       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]}`);
+      for (let i3 = 0;i3 + 1 < coords.length; i3 += 2) {
+        points.push(`${coords[i3]},${coords[i3 + 1]}`);
       }
       return createElement9("polygon", { ...base, points: points.join(" ") });
     }
@@ -4172,9 +6248,9 @@ function GraphicAssociateReferenceSkin(props) {
     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 ?? "");
+      const [a3, b2] = pair.split(/\s+/u);
+      const from = centersById.get(a3 ?? "");
+      const to = centersById.get(b2 ?? "");
       if (!from || !to) {
         return null;
       }
@@ -4558,10 +6634,10 @@ function SelectPointReferenceSkin(props) {
     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);
+      const [x2, y2] = value.split(/\s+/u).map(Number);
       return createElement20(Fragment5, { key: `${value}-${index}` }, createElement20("circle", {
-        cx: x,
-        cy: y,
+        cx: x2,
+        cy: y2,
         r: 5,
         fill: "currentColor",
         "data-qti-point": value,
@@ -4673,12 +6749,15 @@ export {
   uploadInteraction,
   textOf,
   textEntryInteraction,
+  stimulusContentFromNormalized,
   sliderInteraction,
   serializePciMarkup,
   selectPointInteraction,
   scoreResponse,
   sanitizeAttributes,
   resolveTemplate,
+  resolvePnpActivation,
+  resolveCatalogSupports,
   referenceSkin,
   qtiReactPackageName,
   qtiCoreInteractions,
@@ -4721,6 +6800,8 @@ export {
   createAttemptStore,
   collectTemplateIssues,
   collectRpIssues,
+  collectResponseViolations,
+  collectInteractionConstraints,
   choiceInteraction,
   associateInteraction,
   assessmentTestViewFromNormalized,