@citolab/qti-components 8.2.0 → 9.1.0

package/dist/{chunk-OIUK5BFU.js → chunk-5SU3MP6Y.js}

@@ -2,10 +2,10 @@ import {
   QtiTest,
   TestCheckItem,
   TestNavigation
-} from "./chunk-CRLXQZFA.js";
+} from "./chunk-QCPN7E6K.js";
 import {
   QtiAssessmentItem
-} from "./chunk-YLRMOX6C.js";
+} from "./chunk-WKWCOV5P.js";
 import {
   QtiAssociateInteraction,
   QtiChoiceInteraction,
@@ -28,10 +28,10 @@ import {
   QtiSimpleChoice,
   QtiSliderInteraction,
   QtiTextEntryInteraction
-} from "./chunk-Q6ZK4LRH.js";
+} from "./chunk-5BXJRO5O.js";
 import {
   QtiItem
-} from "./chunk-LMGJOBJA.js";
+} from "./chunk-DAUU2NJL.js";
 import {
   watch
 } from "./chunk-4DB4SC5K.js";
@@ -41,907 +41,758 @@ import {
   computedItemContext,
   configContext,
   responseAttributeConverter
-} from "./chunk-7D3NKAGZ.js";
+} from "./chunk-WCWJPIUQ.js";
 
-// ../qti-corrections/dist/mixins/correct-response.mixin.js
+// ../qti-corrections/dist/components/item-correct-response-mode/item-correct-response-mode.js
+import { html, LitElement } from "lit";
 import { property, state } from "lit/decorators.js";
+import { consume } from "@lit/context";
 var __decorate = function(decorators, target, key, desc) {
   var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
   if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
   else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
   return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
-var Correctness;
-(function(Correctness2) {
-  Correctness2["Correct"] = "correct";
-  Correctness2["PartiallyCorrect"] = "partially-correct";
-  Correctness2["Incorrect"] = "incorrect";
-})(Correctness || (Correctness = {}));
-var CorrectResponseMixin = (superClass) => {
-  class CorrectResponseMixinClass extends superClass {
-    constructor() {
-      super(...arguments);
-      this.showCorrectResponse = false;
-      this._handleShowCorrectResponseChange = (_, show) => {
-        this.toggleInternalCorrectResponse(show);
-      };
-      this.showFullCorrectResponse = false;
-      this._handleShowFullCorrectResponseChange = (_, show) => {
-        this.toggleFullCorrectResponse(show);
-      };
-      this.showCandidateCorrection = false;
-      this._handleShowCandidateCorrectionChange = (_, show) => {
-        this.toggleCandidateCorrection(show);
-      };
-      this._correctResponse = null;
-    }
-    /**
-     * The correct response for this interaction. Can be set as a comma-separated
-     * string via attribute or as string/string[] via property.
-     *
-     * @example
-     * ```html
-     * <qti-choice-interaction correct-response="A,B">
-     * ```
-     */
-    set correctResponseAttr(val) {
-      this._correctResponse = val;
-    }
-    get correctResponseAttr() {
-      return this._correctResponse;
-    }
-    get isFullCorrectResponse() {
-      return this._isFullCorrectResponse;
-    }
-    get registersWithItem() {
-      return !this.isFullCorrectResponse && super.registersWithItem;
-    }
-    set isFullCorrectResponse(val) {
-      this._isFullCorrectResponse = val;
-      if (val) {
-        this.setAttribute("inert", "");
-        this.setAttribute("response-identifier", this.responseIdentifier + "_cr");
-        this.setAttribute("answer-key", "");
-      }
-    }
-    get correctResponse() {
-      const responseVariable = this.responseVariable;
-      if (responseVariable?.correctResponse) {
-        return responseVariable.correctResponse;
-      }
-      return this._correctResponse;
-    }
-    set correctResponse(val) {
-      const oldVal = this._correctResponse;
-      this._correctResponse = val;
-      if (val === null || val === void 0) {
-        this.removeAttribute("correct-response");
-      } else {
-        this.setAttribute("correct-response", Array.isArray(val) ? val.join(",") : val);
-      }
-      this.requestUpdate("_correctResponse", oldVal);
-    }
-    // ─── correctness getter ───────────────────────────────────────────────────
-    get correctness() {
-      const correctResponse = this.correctResponse;
-      if (!correctResponse)
-        return null;
-      const currentResponse = this.response;
-      if (currentResponse === null || currentResponse === void 0 || currentResponse === "" || Array.isArray(currentResponse) && currentResponse.length === 0) {
-        return null;
-      }
-      const correctArr = Array.isArray(correctResponse) ? correctResponse : [correctResponse];
-      const responseArr = Array.isArray(currentResponse) ? currentResponse : [currentResponse];
-      const filteredResponseArr = responseArr.filter((r) => r !== "");
-      if (filteredResponseArr.length === 0)
-        return null;
-      const correctCount = filteredResponseArr.filter((r) => correctArr.includes(r)).length;
-      const incorrectCount = filteredResponseArr.filter((r) => !correctArr.includes(r)).length;
-      if (correctCount === correctArr.length && incorrectCount === 0 && filteredResponseArr.length === correctArr.length) {
-        return Correctness.Correct;
-      }
-      if (correctCount > 0 && (correctCount < correctArr.length || incorrectCount > 0)) {
-        return Correctness.PartiallyCorrect;
-      }
-      return Correctness.Incorrect;
-    }
-    // ─── correctionPart ───────────────────────────────────────────────────────
-    get correctionPart() {
-      return "correction";
-    }
-    // ─── toggle methods ───────────────────────────────────────────────────────
-    toggleCorrectResponse(show) {
-      const correctionConfig = this.configContext;
-      const correctResponseMode = correctionConfig?.correctResponseMode || "internal";
-      if (correctResponseMode === "full") {
-        this.toggleFullCorrectResponse(show);
-      } else {
-        this.toggleInternalCorrectResponse(show);
-      }
-    }
-    /**
-     * Whether the full correct response is withheld from a candidate who is already correct.
-     *
-     * Withheld by default, unless the item configures `fullCorrectResponseOnlyWhenIncorrect: false`
-     * — the behaviour `show-full-correct-response` has always had, on the reasoning that a correct
-     * answer already *is* the key.
-     *
-     * An interaction that routes its internal mode here overrides this to false: there, the caller
-     * asked to show the correct response, and silently showing nothing is worse than showing the
-     * candidate the answer they already gave.
-     */
-    get withholdsFullCorrectResponseWhenCorrect() {
-      return this.configContext?.fullCorrectResponseOnlyWhenIncorrect !== false;
-    }
-    async toggleFullCorrectResponse(show) {
-      const nextSibling = this.nextSibling;
-      const nextSiblingIsFullCorrectResponse = nextSibling instanceof HTMLDivElement && nextSibling?.classList.contains("full-correct-response");
-      const correctResponse = this.correctResponse;
-      if (!correctResponse) {
-        return;
-      }
-      const showFullCorrectResponse = show && (!this.withholdsFullCorrectResponseWhenCorrect || this.correctness !== Correctness.Correct);
-      if (!showFullCorrectResponse) {
-        if (!nextSiblingIsFullCorrectResponse) {
-          return;
-        }
-        this.parentElement?.removeChild(nextSibling);
-        return;
-      }
-      if (nextSiblingIsFullCorrectResponse) {
-        return;
-      }
-      const clone = this.cloneNode(true);
-      clone.removeAttribute("show-full-correct-response");
-      clone.removeAttribute("show-correct-response");
-      clone.removeAttribute("show-candidate-correction");
-      const containerDiv = document.createElement("div");
-      containerDiv.classList.add("full-correct-response");
-      if (this.isInline) {
-        containerDiv.classList.add("full-correct-response-inline");
-      } else {
-        containerDiv.classList.add("full-correct-response-block");
-      }
-      containerDiv.role = "full-correct-response";
-      containerDiv.appendChild(clone);
-      clone.isFullCorrectResponse = true;
-      this.parentElement?.insertBefore(containerDiv, this.nextSibling);
-      await clone.updateComplete;
-      clone.response = Array.isArray(correctResponse) ? [...correctResponse] : correctResponse;
-    }
-    toggleInternalCorrectResponse(show) {
-      this._internals.states.delete("show-correct-response");
-      if (show && this.correctResponse) {
-        this._internals.states.add("show-correct-response");
-      }
-    }
-    toggleCandidateCorrection(show) {
-      if (!show) {
-        return;
-      }
-    }
-    // ─── Lifecycle ────────────────────────────────────────────────────────────
-    firstUpdated() {
-      super.firstUpdated();
-      if (this.isFullCorrectResponse) {
-        return;
-      }
-      if (this.showCorrectResponse) {
-        this.toggleInternalCorrectResponse(true);
-      }
-      if (this.showFullCorrectResponse) {
-        this.toggleFullCorrectResponse(true);
-      }
-    }
+var ItemCorrectResponseMode = class extends LitElement {
+  constructor() {
+    super(...arguments);
+    this.label = "Correct response mode";
+    this._options = {
+      internal: "Internal",
+      full: "Full (copy)"
+    };
   }
-  __decorate([
-    property({
-      attribute: "correct-response",
-      reflect: true,
-      converter: responseAttributeConverter({ emptyAs: null })
-    })
-  ], CorrectResponseMixinClass.prototype, "correctResponseAttr", null);
-  __decorate([
-    property({ type: Boolean, attribute: "show-correct-response", reflect: true })
-  ], CorrectResponseMixinClass.prototype, "showCorrectResponse", void 0);
-  __decorate([
-    watch("showCorrectResponse", { waitUntilFirstUpdate: true })
-  ], CorrectResponseMixinClass.prototype, "_handleShowCorrectResponseChange", void 0);
-  __decorate([
-    property({ type: Boolean, attribute: "show-full-correct-response", reflect: true })
-  ], CorrectResponseMixinClass.prototype, "showFullCorrectResponse", void 0);
-  __decorate([
-    watch("showFullCorrectResponse", { waitUntilFirstUpdate: true })
-  ], CorrectResponseMixinClass.prototype, "_handleShowFullCorrectResponseChange", void 0);
-  __decorate([
-    property({ type: Boolean, attribute: "show-candidate-correction", reflect: true })
-  ], CorrectResponseMixinClass.prototype, "showCandidateCorrection", void 0);
-  __decorate([
-    watch("showCandidateCorrection", { waitUntilFirstUpdate: true })
-  ], CorrectResponseMixinClass.prototype, "_handleShowCandidateCorrectionChange", void 0);
-  __decorate([
-    state()
-  ], CorrectResponseMixinClass.prototype, "_isFullCorrectResponse", void 0);
-  __decorate([
-    state()
-  ], CorrectResponseMixinClass.prototype, "_correctResponse", void 0);
-  return CorrectResponseMixinClass;
-};
-
-// ../qti-corrections/dist/styles/correction.styles.js
-import { css } from "lit";
-var correctionPart = css`
-  /* Nothing at all until the item judges this element. */
-  [part~='correction'] {
-    display: none;
+  #switchMode(view) {
+    this.dispatchEvent(new CustomEvent("item-switch-correct-response-mode", {
+      detail: view,
+      bubbles: true
+    }));
   }
+  render() {
+    return html`
+      <label part="label" for="modeSelect">${this.label}</label>
+      <select
+        part="select"
+        id="modeSelect"
+        @change=${(e) => {
+      const el = e.target;
+      this.#switchMode(el.value);
+    }}
+      >
+        ${Object.keys(this._options).map((value) => html`<option value="${value}" ?selected=${value === this.itemContext?.correctResponseMode}>
+              ${this._options[value]}
+            </option>`)}
+      </select>
+    `;
+  }
+};
+__decorate([
+  consume({ context: configContext, subscribe: true })
+], ItemCorrectResponseMode.prototype, "itemContext", void 0);
+__decorate([
+  property({ type: String })
+], ItemCorrectResponseMode.prototype, "label", void 0);
+__decorate([
+  state()
+], ItemCorrectResponseMode.prototype, "_options", void 0);
 
-  [part~='correction-correct'],
-  [part~='correction-incorrect'],
-  [part~='correction-partially-correct'] {
-    display: inline-flex;
-    flex: 0 0 auto;
-
-    /*
-     * The badge aligns ITSELF, and that is the whole of the vertical story.
-     *
-     * It is a flex item with a definite height, so left alone its cross-axis position is decided by
-     * whatever its host says — and the hosts disagree: qti-simple-associable-choice defaults to
-     * align-items: normal, and qti-gap-text gates center behind :not([part~='drag']), so the
-     * same chip centred its badge in the bank and top-aligned it once placed. align-self settles it
-     * from the badge's side, in one line, without touching a single container.
-     *
-     * This replaces an align-items/justify-content: center pair that had never done anything: the
-     * badge is empty — a mask painted over a background — so centring its CONTENTS centres nothing.
-     */
-    align-self: center;
-
-    box-sizing: border-box;
-    width: var(--qti-correction-size, 1em);
-    height: var(--qti-correction-size, 1em);
-    margin-left: var(--qti-glyph-gap, 0.5em);
+// ../qti-corrections/dist/components/item-show-candidate-correction/item-show-candidate-correction.js
+import { css as css2, html as html2, LitElement as LitElement2 } from "lit";
+import { property as property2 } from "lit/decorators.js";
+import { consume as consume2 } from "@lit/context";
 
-    pointer-events: none;
-  }
+// ../qti-corrections/dist/components/styles.js
+import { css } from "lit";
+var form = css`
+  display: inline-flex;
+  align-items: center;
+  cursor: pointer;
+  padding: 0.5rem 1rem;
+  border-radius: 0.25rem;
+  user-select: none;
+`;
+var btn = css`
+  background-color: lightgray;
+  ${form};
+`;
+var dis = css`
+  cursor: not-allowed;
+  opacity: 0.8;
+`;
+var ind = css`
+  ${form};
+  border: 1px solid gray;
 `;
 
-// ../qti-corrections/dist/mixins/candidate-correction.mixin.js
-import { state as state2 } from "lit/decorators.js";
+// ../qti-corrections/dist/components/item-show-candidate-correction/item-show-candidate-correction.js
 var __decorate2 = function(decorators, target, key, desc) {
   var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
   if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
   else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
   return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
-var CandidateCorrectionMixin = (superClass) => {
-  class CandidateCorrectionMixinClass extends CorrectResponseMixin(superClass) {
-    constructor() {
-      super(...arguments);
-      this._candidateCorrection = null;
-    }
-    get correctionPart() {
-      return this._candidateCorrection ? `correction correction-${this._candidateCorrection}` : "correction";
-    }
-    toggleCandidateCorrection(show) {
-      if (this.showCandidateCorrection !== show) {
-        this.showCandidateCorrection = show;
-      }
-      super.toggleCandidateCorrection(show);
-      const internals = this._internals;
-      internals.states.delete("candidate-correct");
-      internals.states.delete("candidate-partially-correct");
-      internals.states.delete("candidate-incorrect");
-      let verdict = null;
-      if (show) {
-        if (this.correctness === Correctness.Correct) {
-          internals.states.add("candidate-correct");
-          verdict = "correct";
-        }
-        if (this.correctness === Correctness.PartiallyCorrect) {
-          internals.states.add("candidate-partially-correct");
-          verdict = "partially-correct";
-        }
-        if (this.correctness === Correctness.Incorrect) {
-          internals.states.add("candidate-incorrect");
-          verdict = "incorrect";
-        }
-      }
-      if (this._candidateCorrection !== verdict) {
-        this._candidateCorrection = verdict;
-      }
+var ItemShowCandidateCorrection = class extends LitElement2 {
+  static {
+    this.styles = css2`
+    :host {
+      ${btn};
     }
-    connectedCallback() {
-      super.connectedCallback?.();
-      queueMicrotask(() => {
-        if (!this.isConnected || this.isFullCorrectResponse) {
-          return;
-        }
-        if (this.showCandidateCorrection) {
-          this.toggleCandidateCorrection(true);
-        }
-      });
+    :host([disabled]) {
+      ${dis};
     }
+  `;
   }
-  __decorate2([
-    state2()
-  ], CandidateCorrectionMixinClass.prototype, "_candidateCorrection", void 0);
-  return CandidateCorrectionMixinClass;
-};
-
-// ../qti-corrections/dist/mixins/choice-correction.mixin.js
-var ChoiceCorrectionMixin = (superClass) => {
-  class ChoiceCorrectionMixinClass extends CandidateCorrectionMixin(superClass) {
-    toggleInternalCorrectResponse(show) {
-      super.toggleInternalCorrectResponse(show);
-      const correctResponse = this.correctResponse;
-      const correctResponses = correctResponse ? Array.isArray(correctResponse) ? correctResponse : [correctResponse] : [];
-      for (const choice of this._choiceElements) {
-        choice.internals.states.delete("correct-response");
-        choice.internals.states.delete("incorrect-response");
-        if (show && correctResponses.length > 0) {
-          choice.internals.states.add(correctResponses.includes(choice.identifier) ? "correct-response" : "incorrect-response");
-        }
-      }
-    }
-    toggleCandidateCorrection(show) {
-      super.toggleCandidateCorrection(show);
-      for (const choice of this._choiceElements) {
-        choice.candidateCorrection = null;
-      }
-      if (!show || !this.correctResponse) {
-        return;
-      }
-      const correctResponses = Array.isArray(this.correctResponse) ? this.correctResponse : [this.correctResponse];
-      const candidateResponses = Array.isArray(this.response) ? this.response : this.response ? [this.response] : [];
-      for (const choice of this._choiceElements) {
-        if (!candidateResponses.includes(choice.identifier)) {
-          continue;
-        }
-        choice.candidateCorrection = correctResponses.includes(choice.identifier) ? "correct" : "incorrect";
-      }
-    }
+  #hasCorrectResponse;
+  // correct response is removed on certain point
+  #previousActiveItem;
+  // Store previous active item reference
+  constructor() {
+    super();
+    this.shown = false;
+    this.disabled = false;
+    this.showCandidateCorrectionText = "Show candidate correction";
+    this.hideCandidateCorrectionText = "Hide candidate correction";
+    this.noCorrectResponseText = "No correct response specified";
+    this.#hasCorrectResponse = false;
+    this.#previousActiveItem = "";
   }
-  return ChoiceCorrectionMixinClass;
-};
-
-// ../qti-corrections/dist/elements/qti-gap-text-correction.js
-import { html } from "lit";
-
-// ../qti-corrections/dist/mixins/active-element-correction.mixin.js
-var ActiveElementCorrectionMixin = (superClass) => {
-  class ActiveElementCorrectionMixinClass extends superClass {
-    #candidateCorrection = null;
-    get candidateCorrection() {
-      return this.#candidateCorrection;
-    }
-    set candidateCorrection(value) {
-      if (this.#candidateCorrection === value)
-        return;
-      const previous = this.#candidateCorrection;
-      this.#candidateCorrection = value;
-      const states = this.internals.states;
-      states.delete("candidate-correct");
-      states.delete("candidate-incorrect");
-      states.delete("candidate-partially-correct");
-      if (value)
-        states.add(`candidate-${value}`);
-      this.requestUpdate("candidateCorrection", previous);
-    }
-    get correctionPart() {
-      return this.#candidateCorrection ? `correction correction-${this.#candidateCorrection}` : "correction";
+  updated() {
+    if (!this.#hasCorrectResponse || this.#previousActiveItem !== this.computedContext?.identifier) {
+      this.#previousActiveItem = this.computedContext?.identifier;
+      const containsCorrectResponse = !!this.computedContext?.variables.some((v) => v["correctResponse"]);
+      const containsMapping = !!this.computedContext?.variables.some((v) => {
+        return v["mapping"]?.mapEntries?.length > 0 || v["areaMapping"]?.areaMapEntries?.length > 0;
+      });
+      this.#hasCorrectResponse = containsCorrectResponse || containsMapping;
     }
+    this.disabled = !this.#hasCorrectResponse;
   }
-  return ActiveElementCorrectionMixinClass;
-};
-
-// ../qti-corrections/dist/elements/qti-gap-text-correction.js
-var QtiGapTextCorrection = class extends ActiveElementCorrectionMixin(QtiGapText) {
-  static {
-    this.styles = [QtiGapText.styles, correctionPart];
+  #toggleState() {
+    if (this.disabled)
+      return;
+    this.dispatchEvent(new CustomEvent("item-show-candidate-correction", {
+      detail: !this.shown,
+      bubbles: true
+    }));
+  }
+  #getDisplayedText() {
+    return this.disabled ? this.noCorrectResponseText : this.shown ? this.hideCandidateCorrectionText : this.showCandidateCorrectionText;
   }
   render() {
-    return html`<div part="control"></div>
-      <slot part="label"></slot>
-      <span part=${this.correctionPart} aria-hidden="true"></span>`;
+    return html2` <div @click="${this.#toggleState}">${this.#getDisplayedText()}</div> `;
   }
 };
+__decorate2([
+  consume2({ context: computedItemContext, subscribe: true })
+], ItemShowCandidateCorrection.prototype, "computedContext", void 0);
+__decorate2([
+  property2({ type: Boolean, reflect: true })
+], ItemShowCandidateCorrection.prototype, "shown", void 0);
+__decorate2([
+  property2({ type: Boolean, reflect: true })
+], ItemShowCandidateCorrection.prototype, "disabled", void 0);
+__decorate2([
+  property2({ type: String })
+], ItemShowCandidateCorrection.prototype, "showCandidateCorrectionText", void 0);
+__decorate2([
+  property2({ type: String })
+], ItemShowCandidateCorrection.prototype, "hideCandidateCorrectionText", void 0);
+__decorate2([
+  property2({ type: String })
+], ItemShowCandidateCorrection.prototype, "noCorrectResponseText", void 0);
 
-// ../qti-corrections/dist/elements/qti-hotspot-choice-correction.js
-import { property as property2 } from "lit/decorators.js";
+// ../qti-corrections/dist/components/item-show-correct-response/item-show-correct-response.js
+import { css as css3, html as html3, LitElement as LitElement3 } from "lit";
+import { property as property3 } from "lit/decorators.js";
+import { consume as consume3 } from "@lit/context";
 var __decorate3 = function(decorators, target, key, desc) {
   var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
   if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
   else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
   return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
-var QtiHotspotChoiceCorrection = class extends ActiveElementCorrectionMixin(QtiHotspotChoice) {
+var ItemShowCorrectResponse = class extends LitElement3 {
   constructor() {
     super(...arguments);
-    this.orderCorrect = null;
+    this.shown = false;
+    this.disabled = false;
+    this.showCorrectText = "Show correct response";
+    this.hideCorrectText = "Hide correct response";
+    this.noCorrectResponseText = "No correct response specified";
+    this.#hasCorrectResponse = false;
+    this.#previousActiveItem = "";
   }
-};
-__decorate3([
-  property2({ attribute: "aria-ordercorrectvalue", type: Number, reflect: true })
-], QtiHotspotChoiceCorrection.prototype, "orderCorrect", void 0);
-
-// ../qti-corrections/dist/elements/qti-hottext-correction.js
-import { html as html2 } from "lit";
-var QtiHottextCorrection = class extends ActiveElementCorrectionMixin(QtiHottext) {
   static {
-    this.styles = [QtiHottext.styles, correctionPart];
-  }
-  render() {
-    return html2`<div part="control"><div part="control-mark"></div></div>
-      <slot part="label"></slot>
-      <span part=${this.correctionPart} aria-hidden="true"></span>`;
+    this.styles = css3`
+    :host {
+      ${btn};
+    }
+    :host([disabled]) {
+      ${dis};
+    }
+  `;
   }
-};
-
-// ../qti-corrections/dist/elements/qti-simple-associable-choice-correction.js
-import { html as html3 } from "lit";
-import { repeat } from "lit/directives/repeat.js";
-var QtiSimpleAssociableChoiceCorrection = class extends ActiveElementCorrectionMixin(QtiSimpleAssociableChoice) {
-  static {
-    this.styles = [QtiSimpleAssociableChoice.styles, correctionPart];
+  #hasCorrectResponse;
+  // correct response is removed on certain point
+  #previousActiveItem;
+  // Store previous active item reference
+  updated() {
+    if (!this.#hasCorrectResponse || this.#previousActiveItem !== this.computedContext?.identifier) {
+      this.#previousActiveItem = this.computedContext?.identifier;
+      const containsCorrectResponse = !!this.computedContext?.variables.some((v) => v["correctResponse"]);
+      const containsMapping = !!this.computedContext?.variables.some((v) => {
+        return v["mapping"]?.mapEntries?.length > 0 || v["areaMapping"]?.areaMapEntries?.length > 0;
+      });
+      this.#hasCorrectResponse = containsCorrectResponse || containsMapping;
+    }
+    this.disabled = !this.#hasCorrectResponse;
   }
-  render() {
-    return html3`
-      <div part="control"></div>
-      <slot part="label"></slot>
-      <span part=${this.correctionPart} aria-hidden="true"></span>
-      <div part="drop">
-        ${repeat(this.drags, (node) => node.getAttribute("identifier"), (node) => node)}
-      </div>
-    `;
+  #toggleState() {
+    if (this.disabled)
+      return;
+    this.dispatchEvent(new CustomEvent("item-show-correct-response", {
+      detail: !this.shown,
+      bubbles: true
+    }));
   }
-};
-
-// ../qti-corrections/dist/elements/qti-simple-choice-correction.js
-import { html as html4, nothing } from "lit";
-var QtiSimpleChoiceCorrection = class extends ActiveElementCorrectionMixin(QtiSimpleChoice) {
-  static {
-    this.styles = [QtiSimpleChoice.styles, correctionPart];
+  #getDisplayedText() {
+    return this.disabled ? this.noCorrectResponseText : this.shown ? this.hideCorrectText : this.showCorrectText;
   }
   render() {
-    return html4`<div part="control" tabindex="0"><div part="control-mark"></div></div>
-      ${this.marker ? html4`<div id="label" part="marker">${this.marker}</div>` : nothing}
-      <slot part="label"></slot>
-      <span part=${this.correctionPart} aria-hidden="true"></span>`;
+    return html3` <div @click="${this.#toggleState}">${this.#getDisplayedText()}</div> `;
   }
 };
+__decorate3([
+  consume3({ context: computedItemContext, subscribe: true })
+], ItemShowCorrectResponse.prototype, "computedContext", void 0);
+__decorate3([
+  property3({ type: Boolean, reflect: true })
+], ItemShowCorrectResponse.prototype, "shown", void 0);
+__decorate3([
+  property3({ type: Boolean, reflect: true })
+], ItemShowCorrectResponse.prototype, "disabled", void 0);
+__decorate3([
+  property3({ type: String })
+], ItemShowCorrectResponse.prototype, "showCorrectText", void 0);
+__decorate3([
+  property3({ type: String })
+], ItemShowCorrectResponse.prototype, "hideCorrectText", void 0);
+__decorate3([
+  property3({ type: String })
+], ItemShowCorrectResponse.prototype, "noCorrectResponseText", void 0);
 
-// ../qti-corrections/dist/components/qti-assessment-item-correction.js
-var QtiAssessmentItemCorrection = class extends QtiAssessmentItem {
-  showCorrectResponse(show) {
-    for (const interaction of this.interactionElements) {
-      interaction.toggleCorrectResponse?.(show);
-    }
-    this.updateControlState("item-show-correct-response", show);
+// ../qti-corrections/dist/components/test-show-correct-response/test-show-correct-response.js
+import { css as css4, html as html4, LitElement as LitElement4 } from "lit";
+import { property as property4 } from "lit/decorators.js";
+import { consume as consume4 } from "@lit/context";
+var __decorate4 = function(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var TestShowCorrectResponse = class extends LitElement4 {
+  constructor() {
+    super(...arguments);
+    this.shown = false;
+    this.disabled = false;
+    this.showCorrectText = "Show correct response";
+    this.hideCorrectText = "Hide correct response";
+    this.noCorrectResponseText = "No correct response specified";
   }
-  showCandidateCorrection(show) {
-    for (const interaction of this.interactionElements) {
-      interaction.toggleCandidateCorrection?.(show);
+  static {
+    this.styles = css4`
+    :host {
+      ${btn};
     }
-    this.updateControlState("item-show-candidate-correction", show);
-  }
-  afterResponseVariableUpdated() {
-    this.showCandidateCorrection(false);
+    :host([disabled]) {
+      ${dis};
+    }
+  `;
   }
-  updateControlState(selector, shown) {
-    let root = this.getRootNode();
-    while (true) {
-      root.querySelectorAll(selector).forEach((control) => control.shown = shown);
-      if (!(root instanceof ShadowRoot))
-        return;
-      root = root.host.getRootNode();
+  #previousActiveItem;
+  // Store previous active item reference
+  willUpdate(_changedProperties) {
+    const activeItem = this.computedContext?.testParts.flatMap((testPart) => testPart.sections.flatMap((section) => section.items)).find((item) => item.active);
+    if (this.#previousActiveItem !== activeItem) {
+      this.shown = false;
+      this.#previousActiveItem = activeItem;
+    }
+    if (activeItem) {
+      const containsCorrectResponse = !!activeItem?.variables?.some((v) => v["correctResponse"]);
+      const containsMapping = !!activeItem?.variables?.some((v) => {
+        return v["mapping"]?.mapEntries?.length > 0 || v["areaMapping"]?.areaMapEntries?.length > 0;
+      });
+      this.disabled = !containsCorrectResponse && !containsMapping;
+    } else {
+      this.disabled = true;
     }
   }
-};
-
-// ../qti-corrections/dist/components/qti-item-correction.js
-var QtiItemCorrection = class extends QtiItem {
-  #onShowCorrectResponse = (event) => {
-    const show = event.detail;
-    this.assessmentItem?.showCorrectResponse?.(show);
-    this.updateControlState("item-show-correct-response", show);
-  };
-  #onShowCandidateCorrection = (event) => {
-    const show = event.detail;
-    this.assessmentItem?.showCandidateCorrection?.(show);
-    this.updateControlState("item-show-candidate-correction", show);
-  };
-  #onSwitchCorrectResponseMode = (event) => {
-    this.assessmentItem?.showCorrectResponse?.(false);
-    this.configContext = {
-      ...this.configContext,
-      correctResponseMode: event.detail
-    };
-  };
-  constructor() {
-    super();
-    this.addEventListener("item-show-correct-response", this.#onShowCorrectResponse);
-    this.addEventListener("item-show-candidate-correction", this.#onShowCandidateCorrection);
-    this.addEventListener("item-switch-correct-response-mode", this.#onSwitchCorrectResponseMode);
+  #toggleState() {
+    if (this.disabled)
+      return;
+    this.shown = !this.shown;
+    this.dispatchEvent(new CustomEvent("test-show-correct-response", {
+      detail: this.shown,
+      bubbles: true
+    }));
   }
-  updateControlState(selector, shown) {
-    this.querySelectorAll(selector).forEach((control) => control.shown = shown);
+  #getDisplayedText() {
+    return this.disabled ? this.noCorrectResponseText : this.shown ? this.hideCorrectText : this.showCorrectText;
   }
-  disconnectedCallback() {
-    this.removeEventListener("item-show-correct-response", this.#onShowCorrectResponse);
-    this.removeEventListener("item-show-candidate-correction", this.#onShowCandidateCorrection);
-    this.removeEventListener("item-switch-correct-response-mode", this.#onSwitchCorrectResponseMode);
-    super.disconnectedCallback();
+  render() {
+    return html4` <div @click="${this.#toggleState}">${this.#getDisplayedText()}</div> `;
   }
 };
+__decorate4([
+  consume4({ context: computedContext, subscribe: true })
+], TestShowCorrectResponse.prototype, "computedContext", void 0);
+__decorate4([
+  property4({ type: Boolean, reflect: true })
+], TestShowCorrectResponse.prototype, "shown", void 0);
+__decorate4([
+  property4({ type: Boolean, reflect: true })
+], TestShowCorrectResponse.prototype, "disabled", void 0);
+__decorate4([
+  property4({ type: String })
+], TestShowCorrectResponse.prototype, "showCorrectText", void 0);
+__decorate4([
+  property4({ type: String })
+], TestShowCorrectResponse.prototype, "hideCorrectText", void 0);
+__decorate4([
+  property4({ type: String })
+], TestShowCorrectResponse.prototype, "noCorrectResponseText", void 0);
 
-// ../qti-corrections/dist/components/test-correction-elements.js
-var TestNavigationCorrection = class extends TestNavigation {
-  #onShowCorrectResponse = (event) => {
-    this.activeAssessmentItem?.showCorrectResponse?.(event.detail);
-  };
-  #onShowCandidateCorrection = (event) => {
-    this.activeAssessmentItem?.showCandidateCorrection?.(event.detail);
-  };
-  constructor() {
-    super();
-    this.addEventListener("test-show-correct-response", this.#onShowCorrectResponse);
-    this.addEventListener("test-show-candidate-correction", this.#onShowCandidateCorrection);
+// ../qti-corrections/dist/styles/correction.styles.js
+import { css as css5 } from "lit";
+var correctionPart = css5`
+  /* Nothing at all until the item judges this element. */
+  [part~='correction'] {
+    display: none;
   }
-  disconnectedCallback() {
-    this.removeEventListener("test-show-correct-response", this.#onShowCorrectResponse);
-    this.removeEventListener("test-show-candidate-correction", this.#onShowCandidateCorrection);
-    super.disconnectedCallback();
+
+  [part~='correction-correct'],
+  [part~='correction-incorrect'],
+  [part~='correction-partially-correct'] {
+    display: inline-flex;
+    flex: 0 0 auto;
+
+    /*
+     * The badge aligns ITSELF, and that is the whole of the vertical story.
+     *
+     * It is a flex item with a definite height, so left alone its cross-axis position is decided by
+     * whatever its host says — and the hosts disagree: qti-simple-associable-choice defaults to
+     * align-items: normal, and qti-gap-text gates center behind :not([part~='drag']), so the
+     * same chip centred its badge in the bank and top-aligned it once placed. align-self settles it
+     * from the badge's side, in one line, without touching a single container.
+     *
+     * This replaces an align-items/justify-content: center pair that had never done anything: the
+     * badge is empty — a mask painted over a background — so centring its CONTENTS centres nothing.
+     */
+    align-self: center;
+
+    box-sizing: border-box;
+    width: var(--qti-correction-size, 1em);
+    height: var(--qti-correction-size, 1em);
+    margin-left: var(--qti-glyph-gap, 0.5em);
+
+    pointer-events: none;
   }
-  /**
-   * Reflect correctness back to the candidate after an ended attempt, for items
-   * the assessment opted in via the standard `qti-item-session-control
-   * show-solution` (QTI 3.0 ItemSessionControl.show-solution) — the player takes
-   * no opinion of its own:
-   * - candidate correction (a mark on the learner's selection) after every attempt;
-   * - the correct response (a mark on the right answer) once the item is done —
-   *   the candidate reached the optimal outcome, or ran out of attempts.
-   */
-  afterAttemptEnded(assessmentItem, computedItem, done) {
-    if (!assessmentItem || !computedItem?.showSolution)
-      return;
-    const correctable = assessmentItem;
-    correctable.showCandidateCorrection?.(true);
-    correctable.showCorrectResponse?.(done);
+`;
+
+// ../qti-corrections/dist/elements/qti-gap-text-correction.js
+import { html as html5 } from "lit";
+
+// ../qti-corrections/dist/mixins/active-element-correction.mixin.js
+var ActiveElementCorrectionMixin = (superClass) => {
+  class ActiveElementCorrectionMixinClass extends superClass {
+    #candidateCorrection = null;
+    get candidateCorrection() {
+      return this.#candidateCorrection;
+    }
+    set candidateCorrection(value) {
+      if (this.#candidateCorrection === value)
+        return;
+      const previous = this.#candidateCorrection;
+      this.#candidateCorrection = value;
+      const states = this.internals.states;
+      states.delete("candidate-correct");
+      states.delete("candidate-incorrect");
+      states.delete("candidate-partially-correct");
+      if (value)
+        states.add(`candidate-${value}`);
+      this.requestUpdate("candidateCorrection", previous);
+    }
+    get correctionPart() {
+      return this.#candidateCorrection ? `correction correction-${this.#candidateCorrection}` : "correction";
+    }
   }
+  return ActiveElementCorrectionMixinClass;
 };
-var QtiTestCorrection = class extends QtiTest {
-  updateAssessmentItemView(assessmentItem, view) {
-    assessmentItem.showCorrectResponse?.(view === "scorer");
+
+// ../qti-corrections/dist/elements/qti-gap-text-correction.js
+var QtiGapTextCorrection = class extends ActiveElementCorrectionMixin(QtiGapText) {
+  static {
+    this.styles = [QtiGapText.styles, correctionPart];
   }
-};
-var TestCheckItemCorrection = class extends TestCheckItem {
-  constructor() {
-    super();
-    this.addEventListener("click", () => {
-      this.dispatchEvent(new CustomEvent("test-show-correct-response", { detail: true, bubbles: true }));
-    });
+  render() {
+    return html5`<div part="control"></div>
+      <slot part="label"></slot>
+      <span part=${this.correctionPart} aria-hidden="true"></span>`;
   }
 };
 
-// ../qti-corrections/dist/components/item-correct-response-mode/item-correct-response-mode.js
-import { html as html5, LitElement } from "lit";
-import { property as property3, state as state3 } from "lit/decorators.js";
-import { consume } from "@lit/context";
-var __decorate4 = function(decorators, target, key, desc) {
+// ../qti-corrections/dist/elements/qti-hotspot-choice-correction.js
+import { property as property5 } from "lit/decorators.js";
+var __decorate5 = function(decorators, target, key, desc) {
   var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
   if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
   else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
   return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
-var ItemCorrectResponseMode = class extends LitElement {
+var QtiHotspotChoiceCorrection = class extends ActiveElementCorrectionMixin(QtiHotspotChoice) {
   constructor() {
     super(...arguments);
-    this.label = "Correct response mode";
-    this._options = {
-      internal: "Internal",
-      full: "Full (copy)"
-    };
+    this.orderCorrect = null;
   }
-  #switchMode(view) {
-    this.dispatchEvent(new CustomEvent("item-switch-correct-response-mode", {
-      detail: view,
-      bubbles: true
-    }));
+};
+__decorate5([
+  property5({ attribute: "aria-ordercorrectvalue", type: Number, reflect: true })
+], QtiHotspotChoiceCorrection.prototype, "orderCorrect", void 0);
+
+// ../qti-corrections/dist/elements/qti-hottext-correction.js
+import { html as html6 } from "lit";
+var QtiHottextCorrection = class extends ActiveElementCorrectionMixin(QtiHottext) {
+  static {
+    this.styles = [QtiHottext.styles, correctionPart];
   }
   render() {
-    return html5`
-      <label part="label" for="modeSelect">${this.label}</label>
-      <select
-        part="select"
-        id="modeSelect"
-        @change=${(e) => {
-      const el = e.target;
-      this.#switchMode(el.value);
-    }}
-      >
-        ${Object.keys(this._options).map((value) => html5`<option value="${value}" ?selected=${value === this.itemContext?.correctResponseMode}>
-              ${this._options[value]}
-            </option>`)}
-      </select>
-    `;
+    return html6`<div part="control"><div part="control-mark"></div></div>
+      <slot part="label"></slot>
+      <span part=${this.correctionPart} aria-hidden="true"></span>`;
   }
 };
-__decorate4([
-  consume({ context: configContext, subscribe: true })
-], ItemCorrectResponseMode.prototype, "itemContext", void 0);
-__decorate4([
-  property3({ type: String })
-], ItemCorrectResponseMode.prototype, "label", void 0);
-__decorate4([
-  state3()
-], ItemCorrectResponseMode.prototype, "_options", void 0);
 
-// ../qti-corrections/dist/components/item-show-candidate-correction/item-show-candidate-correction.js
-import { css as css3, html as html6, LitElement as LitElement2 } from "lit";
-import { property as property4 } from "lit/decorators.js";
-import { consume as consume2 } from "@lit/context";
+// ../qti-corrections/dist/elements/qti-simple-associable-choice-correction.js
+import { html as html7 } from "lit";
+import { repeat } from "lit/directives/repeat.js";
+var QtiSimpleAssociableChoiceCorrection = class extends ActiveElementCorrectionMixin(QtiSimpleAssociableChoice) {
+  static {
+    this.styles = [QtiSimpleAssociableChoice.styles, correctionPart];
+  }
+  render() {
+    return html7`
+      <div part="control"></div>
+      <slot part="label"></slot>
+      <span part=${this.correctionPart} aria-hidden="true"></span>
+      <div part="drop">
+        ${repeat(this.drags, (node) => node.getAttribute("identifier"), (node) => node)}
+      </div>
+    `;
+  }
+};
 
-// ../qti-corrections/dist/components/styles.js
-import { css as css2 } from "lit";
-var form = css2`
-  display: inline-flex;
-  align-items: center;
-  cursor: pointer;
-  padding: 0.5rem 1rem;
-  border-radius: 0.25rem;
-  user-select: none;
-`;
-var btn = css2`
-  background-color: lightgray;
-  ${form};
-`;
-var dis = css2`
-  cursor: not-allowed;
-  opacity: 0.8;
-`;
-var ind = css2`
-  ${form};
-  border: 1px solid gray;
-`;
+// ../qti-corrections/dist/elements/qti-simple-choice-correction.js
+import { html as html8, nothing } from "lit";
+var QtiSimpleChoiceCorrection = class extends ActiveElementCorrectionMixin(QtiSimpleChoice) {
+  static {
+    this.styles = [QtiSimpleChoice.styles, correctionPart];
+  }
+  render() {
+    return html8`<div part="control" tabindex="0"><div part="control-mark"></div></div>
+      ${this.marker ? html8`<div id="label" part="marker">${this.marker}</div>` : nothing}
+      <slot part="label"></slot>
+      <span part=${this.correctionPart} aria-hidden="true"></span>`;
+  }
+};
 
-// ../qti-corrections/dist/components/item-show-candidate-correction/item-show-candidate-correction.js
-var __decorate5 = function(decorators, target, key, desc) {
+// ../qti-corrections/dist/mixins/correct-response.mixin.js
+import { property as property6, state as state2 } from "lit/decorators.js";
+var __decorate6 = function(decorators, target, key, desc) {
   var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
   if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
   else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
   return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
-var ItemShowCandidateCorrection = class extends LitElement2 {
-  static {
-    this.styles = css3`
-    :host {
-      ${btn};
+var Correctness;
+(function(Correctness2) {
+  Correctness2["Correct"] = "correct";
+  Correctness2["PartiallyCorrect"] = "partially-correct";
+  Correctness2["Incorrect"] = "incorrect";
+})(Correctness || (Correctness = {}));
+var CorrectResponseMixin = (superClass) => {
+  class CorrectResponseMixinClass extends superClass {
+    constructor() {
+      super(...arguments);
+      this.showCorrectResponse = false;
+      this._handleShowCorrectResponseChange = (_, show) => {
+        this.toggleInternalCorrectResponse(show);
+      };
+      this.showFullCorrectResponse = false;
+      this._handleShowFullCorrectResponseChange = (_, show) => {
+        this.toggleFullCorrectResponse(show);
+      };
+      this.showCandidateCorrection = false;
+      this._handleShowCandidateCorrectionChange = (_, show) => {
+        this.toggleCandidateCorrection(show);
+      };
+      this._correctResponse = null;
+    }
+    /**
+     * The correct response for this interaction. Can be set as a comma-separated
+     * string via attribute or as string/string[] via property.
+     *
+     * @example
+     * ```html
+     * <qti-choice-interaction correct-response="A,B">
+     * ```
+     */
+    set correctResponseAttr(val) {
+      this._correctResponse = val;
+    }
+    get correctResponseAttr() {
+      return this._correctResponse;
+    }
+    get isFullCorrectResponse() {
+      return this._isFullCorrectResponse;
+    }
+    get registersWithItem() {
+      return !this.isFullCorrectResponse && super.registersWithItem;
+    }
+    set isFullCorrectResponse(val) {
+      this._isFullCorrectResponse = val;
+      if (val) {
+        this.setAttribute("inert", "");
+        this.setAttribute("response-identifier", this.responseIdentifier + "_cr");
+        this.setAttribute("answer-key", "");
+      }
+    }
+    get correctResponse() {
+      const responseVariable = this.responseVariable;
+      if (responseVariable?.correctResponse) {
+        return responseVariable.correctResponse;
+      }
+      return this._correctResponse;
+    }
+    set correctResponse(val) {
+      const oldVal = this._correctResponse;
+      this._correctResponse = val;
+      if (val === null || val === void 0) {
+        this.removeAttribute("correct-response");
+      } else {
+        this.setAttribute("correct-response", Array.isArray(val) ? val.join(",") : val);
+      }
+      this.requestUpdate("_correctResponse", oldVal);
+    }
+    // ─── correctness getter ───────────────────────────────────────────────────
+    get correctness() {
+      const correctResponse = this.correctResponse;
+      if (!correctResponse)
+        return null;
+      const currentResponse = this.response;
+      if (currentResponse === null || currentResponse === void 0 || currentResponse === "" || Array.isArray(currentResponse) && currentResponse.length === 0) {
+        return null;
+      }
+      const correctArr = Array.isArray(correctResponse) ? correctResponse : [correctResponse];
+      const responseArr = Array.isArray(currentResponse) ? currentResponse : [currentResponse];
+      const filteredResponseArr = responseArr.filter((r) => r !== "");
+      if (filteredResponseArr.length === 0)
+        return null;
+      const correctCount = filteredResponseArr.filter((r) => correctArr.includes(r)).length;
+      const incorrectCount = filteredResponseArr.filter((r) => !correctArr.includes(r)).length;
+      if (correctCount === correctArr.length && incorrectCount === 0 && filteredResponseArr.length === correctArr.length) {
+        return Correctness.Correct;
+      }
+      if (correctCount > 0 && (correctCount < correctArr.length || incorrectCount > 0)) {
+        return Correctness.PartiallyCorrect;
+      }
+      return Correctness.Incorrect;
     }
-    :host([disabled]) {
-      ${dis};
+    // ─── correctionPart ───────────────────────────────────────────────────────
+    get correctionPart() {
+      return "correction";
     }
-  `;
-  }
-  #hasCorrectResponse;
-  // correct response is removed on certain point
-  #previousActiveItem;
-  // Store previous active item reference
-  constructor() {
-    super();
-    this.shown = false;
-    this.disabled = false;
-    this.showCandidateCorrectionText = "Show candidate correction";
-    this.hideCandidateCorrectionText = "Hide candidate correction";
-    this.noCorrectResponseText = "No correct response specified";
-    this.#hasCorrectResponse = false;
-    this.#previousActiveItem = "";
-  }
-  updated() {
-    if (!this.#hasCorrectResponse || this.#previousActiveItem !== this.computedContext?.identifier) {
-      this.#previousActiveItem = this.computedContext?.identifier;
-      const containsCorrectResponse = !!this.computedContext?.variables.some((v) => v["correctResponse"]);
-      const containsMapping = !!this.computedContext?.variables.some((v) => {
-        return v["mapping"]?.mapEntries?.length > 0 || v["areaMapping"]?.areaMapEntries?.length > 0;
-      });
-      this.#hasCorrectResponse = containsCorrectResponse || containsMapping;
+    // ─── toggle methods ───────────────────────────────────────────────────────
+    toggleCorrectResponse(show) {
+      const correctionConfig = this.configContext;
+      const correctResponseMode = correctionConfig?.correctResponseMode || "internal";
+      if (correctResponseMode === "full") {
+        this.toggleFullCorrectResponse(show);
+      } else {
+        this.toggleInternalCorrectResponse(show);
+      }
     }
-    this.disabled = !this.#hasCorrectResponse;
-  }
-  #toggleState() {
-    if (this.disabled)
-      return;
-    this.dispatchEvent(new CustomEvent("item-show-candidate-correction", {
-      detail: !this.shown,
-      bubbles: true
-    }));
-  }
-  #getDisplayedText() {
-    return this.disabled ? this.noCorrectResponseText : this.shown ? this.hideCandidateCorrectionText : this.showCandidateCorrectionText;
-  }
-  render() {
-    return html6` <div @click="${this.#toggleState}">${this.#getDisplayedText()}</div> `;
-  }
-};
-__decorate5([
-  consume2({ context: computedItemContext, subscribe: true })
-], ItemShowCandidateCorrection.prototype, "computedContext", void 0);
-__decorate5([
-  property4({ type: Boolean, reflect: true })
-], ItemShowCandidateCorrection.prototype, "shown", void 0);
-__decorate5([
-  property4({ type: Boolean, reflect: true })
-], ItemShowCandidateCorrection.prototype, "disabled", void 0);
-__decorate5([
-  property4({ type: String })
-], ItemShowCandidateCorrection.prototype, "showCandidateCorrectionText", void 0);
-__decorate5([
-  property4({ type: String })
-], ItemShowCandidateCorrection.prototype, "hideCandidateCorrectionText", void 0);
-__decorate5([
-  property4({ type: String })
-], ItemShowCandidateCorrection.prototype, "noCorrectResponseText", void 0);
-
-// ../qti-corrections/dist/components/item-show-correct-response/item-show-correct-response.js
-import { css as css4, html as html7, LitElement as LitElement3 } from "lit";
-import { property as property5 } from "lit/decorators.js";
-import { consume as consume3 } from "@lit/context";
-var __decorate6 = function(decorators, target, key, desc) {
-  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-  return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-var ItemShowCorrectResponse = class extends LitElement3 {
-  constructor() {
-    super(...arguments);
-    this.shown = false;
-    this.disabled = false;
-    this.showCorrectText = "Show correct response";
-    this.hideCorrectText = "Hide correct response";
-    this.noCorrectResponseText = "No correct response specified";
-    this.#hasCorrectResponse = false;
-    this.#previousActiveItem = "";
-  }
-  static {
-    this.styles = css4`
-    :host {
-      ${btn};
+    /**
+     * Whether the full correct response is withheld from a candidate who is already correct.
+     *
+     * Withheld by default, unless the item configures `fullCorrectResponseOnlyWhenIncorrect: false`
+     * — the behaviour `show-full-correct-response` has always had, on the reasoning that a correct
+     * answer already *is* the key.
+     *
+     * An interaction that routes its internal mode here overrides this to false: there, the caller
+     * asked to show the correct response, and silently showing nothing is worse than showing the
+     * candidate the answer they already gave.
+     */
+    get withholdsFullCorrectResponseWhenCorrect() {
+      return this.configContext?.fullCorrectResponseOnlyWhenIncorrect !== false;
     }
-    :host([disabled]) {
-      ${dis};
+    async toggleFullCorrectResponse(show) {
+      const nextSibling = this.nextSibling;
+      const nextSiblingIsFullCorrectResponse = nextSibling instanceof HTMLDivElement && nextSibling?.classList.contains("full-correct-response");
+      const correctResponse = this.correctResponse;
+      if (!correctResponse) {
+        return;
+      }
+      const showFullCorrectResponse = show && (!this.withholdsFullCorrectResponseWhenCorrect || this.correctness !== Correctness.Correct);
+      if (!showFullCorrectResponse) {
+        if (!nextSiblingIsFullCorrectResponse) {
+          return;
+        }
+        this.parentElement?.removeChild(nextSibling);
+        return;
+      }
+      if (nextSiblingIsFullCorrectResponse) {
+        return;
+      }
+      const clone = this.cloneNode(true);
+      clone.removeAttribute("show-full-correct-response");
+      clone.removeAttribute("show-correct-response");
+      clone.removeAttribute("show-candidate-correction");
+      const containerDiv = document.createElement("div");
+      containerDiv.classList.add("full-correct-response");
+      if (this.isInline) {
+        containerDiv.classList.add("full-correct-response-inline");
+      } else {
+        containerDiv.classList.add("full-correct-response-block");
+      }
+      containerDiv.role = "full-correct-response";
+      containerDiv.appendChild(clone);
+      clone.isFullCorrectResponse = true;
+      this.parentElement?.insertBefore(containerDiv, this.nextSibling);
+      await clone.updateComplete;
+      clone.response = Array.isArray(correctResponse) ? [...correctResponse] : correctResponse;
     }
-  `;
-  }
-  #hasCorrectResponse;
-  // correct response is removed on certain point
-  #previousActiveItem;
-  // Store previous active item reference
-  updated() {
-    if (!this.#hasCorrectResponse || this.#previousActiveItem !== this.computedContext?.identifier) {
-      this.#previousActiveItem = this.computedContext?.identifier;
-      const containsCorrectResponse = !!this.computedContext?.variables.some((v) => v["correctResponse"]);
-      const containsMapping = !!this.computedContext?.variables.some((v) => {
-        return v["mapping"]?.mapEntries?.length > 0 || v["areaMapping"]?.areaMapEntries?.length > 0;
-      });
-      this.#hasCorrectResponse = containsCorrectResponse || containsMapping;
+    toggleInternalCorrectResponse(show) {
+      this._internals.states.delete("show-correct-response");
+      if (show && this.correctResponse) {
+        this._internals.states.add("show-correct-response");
+      }
+    }
+    toggleCandidateCorrection(show) {
+      if (!show) {
+        return;
+      }
+    }
+    // ─── Lifecycle ────────────────────────────────────────────────────────────
+    firstUpdated() {
+      super.firstUpdated();
+      if (this.isFullCorrectResponse) {
+        return;
+      }
+      if (this.showCorrectResponse) {
+        this.toggleInternalCorrectResponse(true);
+      }
+      if (this.showFullCorrectResponse) {
+        this.toggleFullCorrectResponse(true);
+      }
     }
-    this.disabled = !this.#hasCorrectResponse;
-  }
-  #toggleState() {
-    if (this.disabled)
-      return;
-    this.dispatchEvent(new CustomEvent("item-show-correct-response", {
-      detail: !this.shown,
-      bubbles: true
-    }));
-  }
-  #getDisplayedText() {
-    return this.disabled ? this.noCorrectResponseText : this.shown ? this.hideCorrectText : this.showCorrectText;
-  }
-  render() {
-    return html7` <div @click="${this.#toggleState}">${this.#getDisplayedText()}</div> `;
   }
+  __decorate6([
+    property6({
+      attribute: "correct-response",
+      reflect: true,
+      converter: responseAttributeConverter({ emptyAs: null })
+    })
+  ], CorrectResponseMixinClass.prototype, "correctResponseAttr", null);
+  __decorate6([
+    property6({ type: Boolean, attribute: "show-correct-response", reflect: true })
+  ], CorrectResponseMixinClass.prototype, "showCorrectResponse", void 0);
+  __decorate6([
+    watch("showCorrectResponse", { waitUntilFirstUpdate: true })
+  ], CorrectResponseMixinClass.prototype, "_handleShowCorrectResponseChange", void 0);
+  __decorate6([
+    property6({ type: Boolean, attribute: "show-full-correct-response", reflect: true })
+  ], CorrectResponseMixinClass.prototype, "showFullCorrectResponse", void 0);
+  __decorate6([
+    watch("showFullCorrectResponse", { waitUntilFirstUpdate: true })
+  ], CorrectResponseMixinClass.prototype, "_handleShowFullCorrectResponseChange", void 0);
+  __decorate6([
+    property6({ type: Boolean, attribute: "show-candidate-correction", reflect: true })
+  ], CorrectResponseMixinClass.prototype, "showCandidateCorrection", void 0);
+  __decorate6([
+    watch("showCandidateCorrection", { waitUntilFirstUpdate: true })
+  ], CorrectResponseMixinClass.prototype, "_handleShowCandidateCorrectionChange", void 0);
+  __decorate6([
+    state2()
+  ], CorrectResponseMixinClass.prototype, "_isFullCorrectResponse", void 0);
+  __decorate6([
+    state2()
+  ], CorrectResponseMixinClass.prototype, "_correctResponse", void 0);
+  return CorrectResponseMixinClass;
 };
-__decorate6([
-  consume3({ context: computedItemContext, subscribe: true })
-], ItemShowCorrectResponse.prototype, "computedContext", void 0);
-__decorate6([
-  property5({ type: Boolean, reflect: true })
-], ItemShowCorrectResponse.prototype, "shown", void 0);
-__decorate6([
-  property5({ type: Boolean, reflect: true })
-], ItemShowCorrectResponse.prototype, "disabled", void 0);
-__decorate6([
-  property5({ type: String })
-], ItemShowCorrectResponse.prototype, "showCorrectText", void 0);
-__decorate6([
-  property5({ type: String })
-], ItemShowCorrectResponse.prototype, "hideCorrectText", void 0);
-__decorate6([
-  property5({ type: String })
-], ItemShowCorrectResponse.prototype, "noCorrectResponseText", void 0);
 
-// ../qti-corrections/dist/components/test-show-correct-response/test-show-correct-response.js
-import { css as css5, html as html8, LitElement as LitElement4 } from "lit";
-import { property as property6 } from "lit/decorators.js";
-import { consume as consume4 } from "@lit/context";
+// ../qti-corrections/dist/mixins/candidate-correction.mixin.js
+import { state as state3 } from "lit/decorators.js";
 var __decorate7 = function(decorators, target, key, desc) {
   var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
   if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
   else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
   return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
-var TestShowCorrectResponse = class extends LitElement4 {
-  constructor() {
-    super(...arguments);
-    this.shown = false;
-    this.disabled = false;
-    this.showCorrectText = "Show correct response";
-    this.hideCorrectText = "Hide correct response";
-    this.noCorrectResponseText = "No correct response specified";
-  }
-  static {
-    this.styles = css5`
-    :host {
-      ${btn};
+var CandidateCorrectionMixin = (superClass) => {
+  class CandidateCorrectionMixinClass extends CorrectResponseMixin(superClass) {
+    constructor() {
+      super(...arguments);
+      this._candidateCorrection = null;
     }
-    :host([disabled]) {
-      ${dis};
+    get correctionPart() {
+      return this._candidateCorrection ? `correction correction-${this._candidateCorrection}` : "correction";
     }
-  `;
-  }
-  #previousActiveItem;
-  // Store previous active item reference
-  willUpdate(_changedProperties) {
-    const activeItem = this.computedContext?.testParts.flatMap((testPart) => testPart.sections.flatMap((section) => section.items)).find((item) => item.active);
-    if (this.#previousActiveItem !== activeItem) {
-      this.shown = false;
-      this.#previousActiveItem = activeItem;
+    toggleCandidateCorrection(show) {
+      if (this.showCandidateCorrection !== show) {
+        this.showCandidateCorrection = show;
+      }
+      super.toggleCandidateCorrection(show);
+      const internals = this._internals;
+      internals.states.delete("candidate-correct");
+      internals.states.delete("candidate-partially-correct");
+      internals.states.delete("candidate-incorrect");
+      let verdict = null;
+      if (show) {
+        if (this.correctness === Correctness.Correct) {
+          internals.states.add("candidate-correct");
+          verdict = "correct";
+        }
+        if (this.correctness === Correctness.PartiallyCorrect) {
+          internals.states.add("candidate-partially-correct");
+          verdict = "partially-correct";
+        }
+        if (this.correctness === Correctness.Incorrect) {
+          internals.states.add("candidate-incorrect");
+          verdict = "incorrect";
+        }
+      }
+      if (this._candidateCorrection !== verdict) {
+        this._candidateCorrection = verdict;
+      }
     }
-    if (activeItem) {
-      const containsCorrectResponse = !!activeItem?.variables?.some((v) => v["correctResponse"]);
-      const containsMapping = !!activeItem?.variables?.some((v) => {
-        return v["mapping"]?.mapEntries?.length > 0 || v["areaMapping"]?.areaMapEntries?.length > 0;
+    connectedCallback() {
+      super.connectedCallback?.();
+      queueMicrotask(() => {
+        if (!this.isConnected || this.isFullCorrectResponse) {
+          return;
+        }
+        if (this.showCandidateCorrection) {
+          this.toggleCandidateCorrection(true);
+        }
       });
-      this.disabled = !containsCorrectResponse && !containsMapping;
-    } else {
-      this.disabled = true;
     }
   }
-  #toggleState() {
-    if (this.disabled)
-      return;
-    this.shown = !this.shown;
-    this.dispatchEvent(new CustomEvent("test-show-correct-response", {
-      detail: this.shown,
-      bubbles: true
-    }));
-  }
-  #getDisplayedText() {
-    return this.disabled ? this.noCorrectResponseText : this.shown ? this.hideCorrectText : this.showCorrectText;
-  }
-  render() {
-    return html8` <div @click="${this.#toggleState}">${this.#getDisplayedText()}</div> `;
-  }
+  __decorate7([
+    state3()
+  ], CandidateCorrectionMixinClass.prototype, "_candidateCorrection", void 0);
+  return CandidateCorrectionMixinClass;
 };
-__decorate7([
-  consume4({ context: computedContext, subscribe: true })
-], TestShowCorrectResponse.prototype, "computedContext", void 0);
-__decorate7([
-  property6({ type: Boolean, reflect: true })
-], TestShowCorrectResponse.prototype, "shown", void 0);
-__decorate7([
-  property6({ type: Boolean, reflect: true })
-], TestShowCorrectResponse.prototype, "disabled", void 0);
-__decorate7([
-  property6({ type: String })
-], TestShowCorrectResponse.prototype, "showCorrectText", void 0);
-__decorate7([
-  property6({ type: String })
-], TestShowCorrectResponse.prototype, "hideCorrectText", void 0);
-__decorate7([
-  property6({ type: String })
-], TestShowCorrectResponse.prototype, "noCorrectResponseText", void 0);
 
 // ../qti-corrections/dist/mixins/drag-drop-correction.mixin.js
 var DragDropCorrectionMixin = (superClass) => {
@@ -968,6 +819,42 @@ var DragDropCorrectionMixin = (superClass) => {
 var QtiAssociateInteractionCorrection = class extends DragDropCorrectionMixin(QtiAssociateInteraction) {
 };
 
+// ../qti-corrections/dist/mixins/choice-correction.mixin.js
+var ChoiceCorrectionMixin = (superClass) => {
+  class ChoiceCorrectionMixinClass extends CandidateCorrectionMixin(superClass) {
+    toggleInternalCorrectResponse(show) {
+      super.toggleInternalCorrectResponse(show);
+      const correctResponse = this.correctResponse;
+      const correctResponses = correctResponse ? Array.isArray(correctResponse) ? correctResponse : [correctResponse] : [];
+      for (const choice of this._choiceElements) {
+        choice.internals.states.delete("correct-response");
+        choice.internals.states.delete("incorrect-response");
+        if (show && correctResponses.length > 0) {
+          choice.internals.states.add(correctResponses.includes(choice.identifier) ? "correct-response" : "incorrect-response");
+        }
+      }
+    }
+    toggleCandidateCorrection(show) {
+      super.toggleCandidateCorrection(show);
+      for (const choice of this._choiceElements) {
+        choice.candidateCorrection = null;
+      }
+      if (!show || !this.correctResponse) {
+        return;
+      }
+      const correctResponses = Array.isArray(this.correctResponse) ? this.correctResponse : [this.correctResponse];
+      const candidateResponses = Array.isArray(this.response) ? this.response : this.response ? [this.response] : [];
+      for (const choice of this._choiceElements) {
+        if (!candidateResponses.includes(choice.identifier)) {
+          continue;
+        }
+        choice.candidateCorrection = correctResponses.includes(choice.identifier) ? "correct" : "incorrect";
+      }
+    }
+  }
+  return ChoiceCorrectionMixinClass;
+};
+
 // ../qti-corrections/dist/interactions/qti-choice-interaction-correction.js
 var QtiChoiceInteractionCorrection = class extends ChoiceCorrectionMixin(QtiChoiceInteraction) {
 };
@@ -1610,27 +1497,135 @@ var QtiTextEntryInteractionCorrection = class extends CandidateCorrectionMixin(Q
   }
 };
 
+// ../qti-corrections/dist/components/qti-assessment-item-correction.js
+var QtiAssessmentItemCorrection = class extends QtiAssessmentItem {
+  showCorrectResponse(show) {
+    for (const interaction of this.interactionElements) {
+      interaction.toggleCorrectResponse?.(show);
+    }
+    this.updateControlState("item-show-correct-response", show);
+  }
+  showCandidateCorrection(show) {
+    for (const interaction of this.interactionElements) {
+      interaction.toggleCandidateCorrection?.(show);
+    }
+    this.updateControlState("item-show-candidate-correction", show);
+  }
+  afterResponseVariableUpdated() {
+    this.showCandidateCorrection(false);
+  }
+  updateControlState(selector, shown) {
+    let root = this.getRootNode();
+    while (true) {
+      root.querySelectorAll(selector).forEach((control) => control.shown = shown);
+      if (!(root instanceof ShadowRoot))
+        return;
+      root = root.host.getRootNode();
+    }
+  }
+};
+
+// ../qti-corrections/dist/components/qti-item-correction.js
+var QtiItemCorrection = class extends QtiItem {
+  #onShowCorrectResponse = (event) => {
+    const show = event.detail;
+    this.assessmentItem?.showCorrectResponse?.(show);
+    this.updateControlState("item-show-correct-response", show);
+  };
+  #onShowCandidateCorrection = (event) => {
+    const show = event.detail;
+    this.assessmentItem?.showCandidateCorrection?.(show);
+    this.updateControlState("item-show-candidate-correction", show);
+  };
+  #onSwitchCorrectResponseMode = (event) => {
+    this.assessmentItem?.showCorrectResponse?.(false);
+    this.configContext = {
+      ...this.configContext,
+      correctResponseMode: event.detail
+    };
+  };
+  constructor() {
+    super();
+    this.addEventListener("item-show-correct-response", this.#onShowCorrectResponse);
+    this.addEventListener("item-show-candidate-correction", this.#onShowCandidateCorrection);
+    this.addEventListener("item-switch-correct-response-mode", this.#onSwitchCorrectResponseMode);
+  }
+  updateControlState(selector, shown) {
+    this.querySelectorAll(selector).forEach((control) => control.shown = shown);
+  }
+  disconnectedCallback() {
+    this.removeEventListener("item-show-correct-response", this.#onShowCorrectResponse);
+    this.removeEventListener("item-show-candidate-correction", this.#onShowCandidateCorrection);
+    this.removeEventListener("item-switch-correct-response-mode", this.#onSwitchCorrectResponseMode);
+    super.disconnectedCallback();
+  }
+};
+
+// ../qti-corrections/dist/components/test-correction-elements.js
+var TestNavigationCorrection = class extends TestNavigation {
+  #onShowCorrectResponse = (event) => {
+    this.activeAssessmentItem?.showCorrectResponse?.(event.detail);
+  };
+  #onShowCandidateCorrection = (event) => {
+    this.activeAssessmentItem?.showCandidateCorrection?.(event.detail);
+  };
+  constructor() {
+    super();
+    this.addEventListener("test-show-correct-response", this.#onShowCorrectResponse);
+    this.addEventListener("test-show-candidate-correction", this.#onShowCandidateCorrection);
+  }
+  disconnectedCallback() {
+    this.removeEventListener("test-show-correct-response", this.#onShowCorrectResponse);
+    this.removeEventListener("test-show-candidate-correction", this.#onShowCandidateCorrection);
+    super.disconnectedCallback();
+  }
+  /**
+   * Reflect correctness back to the candidate after an ended attempt, for items
+   * the assessment opted in via the standard `qti-item-session-control
+   * show-solution` (QTI 3.0 ItemSessionControl.show-solution) — the player takes
+   * no opinion of its own:
+   * - candidate correction (a mark on the learner's selection) after every attempt;
+   * - the correct response (a mark on the right answer) once the item is done —
+   *   the candidate reached the optimal outcome, or ran out of attempts.
+   */
+  afterAttemptEnded(assessmentItem, computedItem, done) {
+    if (!assessmentItem || !computedItem?.showSolution)
+      return;
+    const correctable = assessmentItem;
+    correctable.showCandidateCorrection?.(true);
+    correctable.showCorrectResponse?.(done);
+  }
+};
+var QtiTestCorrection = class extends QtiTest {
+  updateAssessmentItemView(assessmentItem, view) {
+    assessmentItem.showCorrectResponse?.(view === "scorer");
+  }
+};
+var TestCheckItemCorrection = class extends TestCheckItem {
+  constructor() {
+    super();
+    this.addEventListener("click", () => {
+      this.dispatchEvent(new CustomEvent("test-show-correct-response", { detail: true, bubbles: true }));
+    });
+  }
+};
+
 export {
-  Correctness,
-  CorrectResponseMixin,
+  ItemCorrectResponseMode,
+  ItemShowCandidateCorrection,
+  ItemShowCorrectResponse,
+  TestShowCorrectResponse,
   correctionPart,
-  CandidateCorrectionMixin,
-  ChoiceCorrectionMixin,
   QtiGapTextCorrection,
   QtiHotspotChoiceCorrection,
   QtiHottextCorrection,
   QtiSimpleAssociableChoiceCorrection,
   QtiSimpleChoiceCorrection,
-  QtiAssessmentItemCorrection,
-  QtiItemCorrection,
-  TestNavigationCorrection,
-  QtiTestCorrection,
-  TestCheckItemCorrection,
-  ItemCorrectResponseMode,
-  ItemShowCandidateCorrection,
-  ItemShowCorrectResponse,
-  TestShowCorrectResponse,
+  Correctness,
+  CorrectResponseMixin,
+  CandidateCorrectionMixin,
   QtiAssociateInteractionCorrection,
+  ChoiceCorrectionMixin,
   QtiChoiceInteractionCorrection,
   QtiExtendedTextInteractionCorrection,
   QtiGapMatchInteractionCorrection,
@@ -1645,6 +1640,11 @@ export {
   QtiPortableCustomInteractionCorrection,
   QtiSelectPointInteractionCorrection,
   QtiSliderInteractionCorrection,
-  QtiTextEntryInteractionCorrection
+  QtiTextEntryInteractionCorrection,
+  QtiAssessmentItemCorrection,
+  QtiItemCorrection,
+  TestNavigationCorrection,
+  QtiTestCorrection,
+  TestCheckItemCorrection
 };
-//# sourceMappingURL=chunk-OIUK5BFU.js.map
+//# sourceMappingURL=chunk-5SU3MP6Y.js.map