@qti-editor/interaction-associate 0.1.0

package/dist/components/qti-associate-interaction/qti-associate-interaction.commands.d.ts

@@ -0,0 +1,22 @@
+/**
+ * QTI Associate Interaction Commands
+ *
+ * ProseMirror commands for inserting and manipulating associate interactions.
+ */
+import type { Command } from 'prosemirror-state';
+/**
+ * Command to insert an associate interaction at the current selection
+ */
+export declare const insertAssociateInteraction: Command;
+/**
+ * Handles Enter inside qti-simple-associable-choice paragraphs by inserting a new empty
+ * sibling qti-simple-associable-choice directly after the current one.
+ */
+export declare const insertAssociableChoiceOnEnter: Command;
+/**
+ * Enter command chain for associate interactions.
+ * 1) Insert new associable choice when inside qti-associate-interaction.
+ * 2) Fallback to regular block split behavior elsewhere.
+ */
+export declare const qtiAssociateEnterCommand: Command;
+//# sourceMappingURL=qti-associate-interaction.commands.d.ts.map

package/dist/components/qti-associate-interaction/qti-associate-interaction.commands.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"qti-associate-interaction.commands.d.ts","sourceRoot":"","sources":["../../../src/components/qti-associate-interaction/qti-associate-interaction.commands.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAOH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,mBAAmB,CAAC;AAGjD;;GAEG;AACH,eAAO,MAAM,0BAA0B,EAAE,OA4CxC,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,6BAA6B,EAAE,OA0B3C,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,wBAAwB,EAAE,OAAkE,CAAC"}

package/dist/components/qti-associate-interaction/qti-associate-interaction.commands.js

@@ -0,0 +1,71 @@
+/**
+ * QTI Associate Interaction Commands
+ *
+ * ProseMirror commands for inserting and manipulating associate interactions.
+ */
+import { chainCommands, splitBlock } from 'prosemirror-commands';
+import { createInsertSiblingOnEnterCommand } from '@qti-editor/interaction-shared/commands/enter.js';
+import { createInsertBlockInteractionCommand } from '@qti-editor/interaction-shared/commands/insert.js';
+import { translateQti } from '@qti-editor/interaction-shared';
+/**
+ * Command to insert an associate interaction at the current selection
+ */
+export const insertAssociateInteraction = (state, dispatch, view) => {
+    const target = view?.dom ?? null;
+    return createInsertBlockInteractionCommand({
+        createNode: currentState => {
+            const { schema } = currentState;
+            const promptType = schema.nodes.qtiPrompt;
+            const promptParagraphType = schema.nodes.qtiPromptParagraph;
+            const associableChoiceType = schema.nodes.qtiSimpleAssociableChoice;
+            const associableChoiceParagraphType = schema.nodes.qtiSimpleAssociableChoiceParagraph;
+            const interactionType = schema.nodes.qtiAssociateInteraction;
+            if (!promptType || !promptParagraphType || !associableChoiceType || !associableChoiceParagraphType || !interactionType) {
+                return null;
+            }
+            const responseIdentifier = `RESPONSE_${crypto.randomUUID()}`;
+            const prompt = promptType.create(null, promptParagraphType.create(null, schema.text(translateQti('prompt.associate.default', { target }))));
+            const choices = [
+                associableChoiceType.create({ identifier: `CHOICE_${crypto.randomUUID()}`, matchMax: 2 }, associableChoiceParagraphType.create(null, schema.text(translateQti('choice.itemA', { target })))),
+                associableChoiceType.create({ identifier: `CHOICE_${crypto.randomUUID()}`, matchMax: 2 }, associableChoiceParagraphType.create(null, schema.text(translateQti('choice.itemB', { target })))),
+                associableChoiceType.create({ identifier: `CHOICE_${crypto.randomUUID()}`, matchMax: 2 }, associableChoiceParagraphType.create(null, schema.text(translateQti('choice.itemC', { target })))),
+                associableChoiceType.create({ identifier: `CHOICE_${crypto.randomUUID()}`, matchMax: 2 }, associableChoiceParagraphType.create(null, schema.text(translateQti('choice.option1', { target })))),
+            ];
+            return interactionType.create({ responseIdentifier, maxAssociations: 3 }, [prompt, ...choices]);
+        },
+        selectionOffset: 2,
+    })(state, dispatch);
+};
+/**
+ * Handles Enter inside qti-simple-associable-choice paragraphs by inserting a new empty
+ * sibling qti-simple-associable-choice directly after the current one.
+ */
+export const insertAssociableChoiceOnEnter = (state, dispatch) => {
+    const choiceType = state.schema.nodes.qtiSimpleAssociableChoice;
+    const paragraphType = state.schema.nodes.qtiSimpleAssociableChoiceParagraph;
+    const interactionType = state.schema.nodes.qtiAssociateInteraction;
+    if (!choiceType || !paragraphType || !interactionType)
+        return false;
+    // Only handle enter when inside qtiAssociateInteraction
+    const { selection } = state;
+    let insideAssociate = false;
+    for (let depth = selection.$from.depth; depth >= 0; depth--) {
+        if (selection.$from.node(depth).type === interactionType) {
+            insideAssociate = true;
+            break;
+        }
+    }
+    if (!insideAssociate)
+        return false;
+    return createInsertSiblingOnEnterCommand({
+        ancestorNodeName: 'qtiSimpleAssociableChoice',
+        selectionOffset: 2,
+        createSiblingNode: () => choiceType.create({ identifier: `CHOICE_${crypto.randomUUID()}`, matchMax: 2 }, paragraphType.create()),
+    })(state, dispatch);
+};
+/**
+ * Enter command chain for associate interactions.
+ * 1) Insert new associable choice when inside qti-associate-interaction.
+ * 2) Fallback to regular block split behavior elsewhere.
+ */
+export const qtiAssociateEnterCommand = chainCommands(insertAssociableChoiceOnEnter, splitBlock);

package/dist/components/qti-associate-interaction/qti-associate-interaction.compose.d.ts

@@ -0,0 +1,3 @@
+import type { InteractionComposeResult } from '@qti-editor/interaction-shared/composer/types.js';
+export declare function composeAssociateInteractionElement(sourceElement: Element, xmlDoc: Document): InteractionComposeResult;
+//# sourceMappingURL=qti-associate-interaction.compose.d.ts.map

package/dist/components/qti-associate-interaction/qti-associate-interaction.compose.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"qti-associate-interaction.compose.d.ts","sourceRoot":"","sources":["../../../src/components/qti-associate-interaction/qti-associate-interaction.compose.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAmB,wBAAwB,EAAkC,MAAM,kDAAkD,CAAC;AAclJ,wBAAgB,kCAAkC,CAAC,aAAa,EAAE,OAAO,EAAE,MAAM,EAAE,QAAQ,GAAG,wBAAwB,CA6CrH"}

package/dist/components/qti-associate-interaction/qti-associate-interaction.compose.js

@@ -0,0 +1,56 @@
+import { associateInteractionComposerMetadata } from '../../composer/metadata.js';
+function toFiniteNumber(value, fallback) {
+    if (value == null || value.trim().length === 0)
+        return fallback;
+    const parsed = Number(value);
+    return Number.isFinite(parsed) ? parsed : fallback;
+}
+function toNonEmptyString(value) {
+    if (!value)
+        return null;
+    const trimmed = value.trim();
+    return trimmed.length > 0 ? trimmed : null;
+}
+export function composeAssociateInteractionElement(sourceElement, xmlDoc) {
+    const metadata = associateInteractionComposerMetadata;
+    const warnings = [];
+    const normalizedElement = xmlDoc.importNode(sourceElement, true);
+    const responseIdentifier = toNonEmptyString(sourceElement.getAttribute('response-identifier'));
+    const correctResponse = toNonEmptyString(sourceElement.getAttribute('correct-response'));
+    const maxAssociations = toFiniteNumber(sourceElement.getAttribute('max-associations'), 1);
+    const minAssociations = toFiniteNumber(sourceElement.getAttribute('min-associations'), 0);
+    const editorOnlyAttributes = [...metadata.editorOnlyAttributes];
+    editorOnlyAttributes.forEach(attr => normalizedElement.removeAttribute(attr));
+    normalizedElement.setAttribute('max-associations', String(maxAssociations > 0 ? maxAssociations : 1));
+    if (minAssociations > 0) {
+        normalizedElement.setAttribute('min-associations', String(minAssociations));
+    }
+    else {
+        normalizedElement.removeAttribute('min-associations');
+    }
+    let responseDeclaration;
+    if (!responseIdentifier) {
+        warnings.push({
+            code: 'MISSING_RESPONSE_IDENTIFIER',
+            message: 'qti-associate-interaction is missing response-identifier; declaration will be skipped.',
+            tagName: metadata.tagName,
+        });
+    }
+    else {
+        responseDeclaration = {
+            identifier: responseIdentifier,
+            cardinality: maxAssociations > 1 ? 'multiple' : 'single',
+            baseType: 'identifier',
+            correctResponse: correctResponse ?? undefined,
+            sourceTag: metadata.tagName,
+        };
+    }
+    return {
+        normalizedElement,
+        responseDeclaration,
+        responseProcessingTemplate: metadata.responseProcessingTemplate,
+        responseProcessingKind: metadata.responseProcessing.internalKind,
+        editorOnlyAttributes,
+        warnings,
+    };
+}

package/dist/components/qti-associate-interaction/qti-associate-interaction.d.ts

@@ -0,0 +1,62 @@
+import { Interaction } from '@qti-editor/interaction-shared/components/interaction.js';
+/** Association pair: [firstIdentifier, secondIdentifier] */
+export type AssociatePair = [string, string];
+/**
+ * Event detail for associate pair changes.
+ */
+export interface AssociatePairChangeDetail {
+    pairs: AssociatePair[];
+}
+/**
+ * Editor component for qti-associate-interaction.
+ * Choices are shown in a pool; click a choice then click a drop slot to form a pair.
+ */
+export declare class QtiAssociateInteractionEdit extends Interaction {
+    static styles: import("lit").CSSResultGroup;
+    private readonly i18n;
+    maxAssociations: number;
+    minAssociations: number;
+    shuffle: boolean;
+    correctResponse: string | null;
+    private _renderTrigger;
+    private _setupDone;
+    private _labelCache;
+    private _observer;
+    private _lastEmittedResponse;
+    private get _state();
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    firstUpdated(): void;
+    private _onSlotChange;
+    private _trySetup;
+    private _setupMutationObserver;
+    private _observeMutations;
+    private _parseCorrectResponse;
+    private _serializeCurrentPairs;
+    private _syncStateFromCorrectResponse;
+    private _emitChange;
+    private _triggerRender;
+    private _getInteractionKey;
+    private _getChoices;
+    private _buildLabelCache;
+    private _getLabel;
+    private _onKeyDown;
+    private _onChoiceClick;
+    private _clearSlot;
+    private _placeInSlot;
+    /**
+     * Ensure there is always exactly one empty container at the end,
+     * and no completely empty containers in the middle.
+     */
+    private _normalizeContainers;
+    private _cancelPending;
+    private _renderDropContainer;
+    updated(changedProperties: Map<string, unknown>): void;
+    render(): import("lit").TemplateResult<1>;
+}
+declare global {
+    interface HTMLElementEventMap {
+        'associate-pair-change': CustomEvent<AssociatePairChangeDetail>;
+    }
+}
+//# sourceMappingURL=qti-associate-interaction.d.ts.map

package/dist/components/qti-associate-interaction/qti-associate-interaction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"qti-associate-interaction.d.ts","sourceRoot":"","sources":["../../../src/components/qti-associate-interaction/qti-associate-interaction.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,WAAW,EAAE,MAAM,0DAA0D,CAAC;AAKvF,4DAA4D;AAC5D,MAAM,MAAM,aAAa,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;AAE7C;;GAEG;AACH,MAAM,WAAW,yBAAyB;IACxC,KAAK,EAAE,aAAa,EAAE,CAAC;CACxB;AA+BD;;;GAGG;AACH,qBAAa,2BAA4B,SAAQ,WAAW;IAC1D,OAAgB,MAAM,+BAAU;IAEhC,OAAO,CAAC,QAAQ,CAAC,IAAI,CAA+B;IAGpD,eAAe,EAAE,MAAM,CAAK;IAG5B,eAAe,EAAE,MAAM,CAAK;IAG5B,OAAO,EAAE,OAAO,CAAS;IAGzB,eAAe,EAAE,MAAM,GAAG,IAAI,CAAQ;IAGtC,OAAO,CAAC,cAAc,CAAK;IAE3B,OAAO,CAAC,UAAU,CAAS;IAC3B,OAAO,CAAC,WAAW,CAA6B;IAChD,OAAO,CAAC,SAAS,CAAiC;IAClD,OAAO,CAAC,oBAAoB,CAAuB;IAEnD,OAAO,KAAK,MAAM,GAEjB;IAEQ,iBAAiB;IAOjB,oBAAoB;IASpB,YAAY;IAIrB,OAAO,CAAC,aAAa,CAEnB;IAEF,OAAO,CAAC,SAAS;IAYjB,OAAO,CAAC,sBAAsB;IAQ9B,OAAO,CAAC,iBAAiB;IAIzB,OAAO,CAAC,qBAAqB;IAsB7B,OAAO,CAAC,sBAAsB;IAK9B,OAAO,CAAC,6BAA6B;IAOrC,OAAO,CAAC,WAAW;IAUnB,OAAO,CAAC,cAAc;IAItB,OAAO,CAAC,kBAAkB;IAI1B,OAAO,CAAC,WAAW;IAInB,OAAO,CAAC,gBAAgB;IAYxB,OAAO,CAAC,SAAS;IAMjB,OAAO,CAAC,UAAU,CAIhB;IAEF,OAAO,CAAC,cAAc,CAmBpB;IAEF,OAAO,CAAC,UAAU;IAWlB,OAAO,CAAC,YAAY;IAsBpB;;;OAGG;IACH,OAAO,CAAC,oBAAoB;IAO5B,OAAO,CAAC,cAAc;IAOtB,OAAO,CAAC,oBAAoB;IA4CnB,OAAO,CAAC,iBAAiB,EAAE,GAAG,CAAC,MAAM,EAAE,OAAO,CAAC;IAW/C,MAAM;CAShB;AAED,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,mBAAmB;QAC3B,uBAAuB,EAAE,WAAW,CAAC,yBAAyB,CAAC,CAAC;KACjE;CACF"}

package/dist/components/qti-associate-interaction/qti-associate-interaction.js

@@ -0,0 +1,302 @@
+var __decorate = (this && this.__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;
+};
+import { html, nothing } from 'lit';
+import { property, state } from 'lit/decorators.js';
+import { Interaction } from '@qti-editor/interaction-shared/components/interaction.js';
+import { QtiI18nController } from '@qti-editor/interaction-shared';
+import styles from './qti-associate-interaction.styles.js';
+const associateStates = new Map();
+function getState(key) {
+    if (!associateStates.has(key)) {
+        associateStates.set(key, { pendingId: null, containers: [{ left: null, right: null }] });
+    }
+    return associateStates.get(key);
+}
+function stateToPairs(containers) {
+    return containers
+        .filter(c => c.left !== null && c.right !== null)
+        .map(c => [c.left, c.right]);
+}
+/**
+ * Editor component for qti-associate-interaction.
+ * Choices are shown in a pool; click a choice then click a drop slot to form a pair.
+ */
+export class QtiAssociateInteractionEdit extends Interaction {
+    constructor() {
+        super(...arguments);
+        this.i18n = new QtiI18nController(this);
+        this.maxAssociations = 1;
+        this.minAssociations = 0;
+        this.shuffle = false;
+        this.correctResponse = null;
+        this._renderTrigger = 0;
+        this._setupDone = false;
+        this._labelCache = new Map();
+        this._observer = null;
+        this._lastEmittedResponse = null;
+        this._onSlotChange = () => {
+            this._trySetup();
+        };
+        // ─── Event Handling ─────────────────────────────────────────────────────
+        this._onKeyDown = (e) => {
+            if (e.key === 'Escape' && this._state.pendingId) {
+                this._cancelPending();
+            }
+        };
+        this._onChoiceClick = (e) => {
+            const path = e.composedPath();
+            const choiceIndex = path.findIndex(el => el instanceof HTMLElement && el.tagName === 'QTI-SIMPLE-ASSOCIABLE-CHOICE');
+            if (choiceIndex < 0)
+                return;
+            const choice = path[choiceIndex];
+            const identifier = choice.getAttribute('identifier');
+            if (!identifier)
+                return;
+            e.stopPropagation();
+            const state = this._state;
+            if (state.pendingId === identifier) {
+                state.pendingId = null;
+            }
+            else {
+                state.pendingId = identifier;
+            }
+            this._triggerRender();
+        };
+    }
+    get _state() {
+        return getState(this._getInteractionKey());
+    }
+    connectedCallback() {
+        super.connectedCallback();
+        this._syncStateFromCorrectResponse();
+        document.addEventListener('keydown', this._onKeyDown);
+        requestAnimationFrame(() => this._trySetup());
+    }
+    disconnectedCallback() {
+        super.disconnectedCallback();
+        this.removeEventListener('click', this._onChoiceClick);
+        document.removeEventListener('keydown', this._onKeyDown);
+        this._observer?.disconnect();
+        this._observer = null;
+        this._setupDone = false;
+    }
+    firstUpdated() {
+        this._trySetup();
+    }
+    _trySetup() {
+        if (this._setupDone)
+            return;
+        const choices = this.querySelectorAll('qti-simple-associable-choice');
+        if (choices.length < 2)
+            return;
+        this._setupDone = true;
+        this._buildLabelCache();
+        this.addEventListener('click', this._onChoiceClick);
+        this._setupMutationObserver();
+        this._triggerRender();
+    }
+    _setupMutationObserver() {
+        this._observer = new MutationObserver(() => {
+            this._buildLabelCache();
+            this.requestUpdate();
+        });
+        this._observeMutations();
+    }
+    _observeMutations() {
+        this._observer?.observe(this, { childList: true, subtree: true, characterData: true });
+    }
+    _parseCorrectResponse() {
+        const state = this._state;
+        if (!this.correctResponse) {
+            state.containers = [{ left: null, right: null }];
+            return;
+        }
+        try {
+            const parsed = JSON.parse(this.correctResponse);
+            if (Array.isArray(parsed)) {
+                const valid = parsed.filter(p => Array.isArray(p) && p.length === 2 && p[0] && p[1]);
+                state.containers = [
+                    ...valid.map(([l, r]) => ({ left: l, right: r })),
+                    { left: null, right: null },
+                ];
+                return;
+            }
+        }
+        catch {
+            // Invalid JSON, ignore
+        }
+        state.containers = [{ left: null, right: null }];
+    }
+    _serializeCurrentPairs() {
+        const pairs = stateToPairs(this._state.containers);
+        return pairs.length > 0 ? JSON.stringify(pairs) : null;
+    }
+    _syncStateFromCorrectResponse() {
+        if (this.correctResponse === this._serializeCurrentPairs()) {
+            return;
+        }
+        this._parseCorrectResponse();
+    }
+    _emitChange() {
+        const pairs = stateToPairs(this._state.containers);
+        this._lastEmittedResponse = pairs.length > 0 ? JSON.stringify(pairs) : null;
+        this.dispatchEvent(new CustomEvent('associate-pair-change', {
+            detail: { pairs },
+            bubbles: true,
+            composed: true
+        }));
+    }
+    _triggerRender() {
+        this._renderTrigger++;
+    }
+    _getInteractionKey() {
+        return this.responseIdentifier || this.getAttribute('response-identifier') || 'default';
+    }
+    _getChoices() {
+        return Array.from(this.querySelectorAll('qti-simple-associable-choice'));
+    }
+    _buildLabelCache() {
+        this._labelCache.clear();
+        for (const choice of this._getChoices()) {
+            const id = choice.getAttribute('identifier');
+            if (id) {
+                const clone = choice.cloneNode(true);
+                clone.querySelectorAll('qti-simple-associable-choice').forEach(el => el.remove());
+                this._labelCache.set(id, clone.textContent?.trim() || id);
+            }
+        }
+    }
+    _getLabel(id) {
+        return this._labelCache.get(id) || id;
+    }
+    _clearSlot(containerIndex, side, e) {
+        e.stopPropagation();
+        const state = this._state;
+        const container = state.containers[containerIndex];
+        if (!container)
+            return;
+        container[side] = null;
+        this._normalizeContainers();
+        this._emitChange();
+        this._triggerRender();
+    }
+    _placeInSlot(containerIndex, side, e) {
+        e.stopPropagation();
+        const state = this._state;
+        const container = state.containers[containerIndex];
+        if (!container)
+            return;
+        if (container[side] !== null)
+            return; // slot is filled — do nothing
+        if (state.pendingId === null)
+            return;
+        // Remove pendingId from any existing slot
+        for (const c of state.containers) {
+            if (c.left === state.pendingId)
+                c.left = null;
+            if (c.right === state.pendingId)
+                c.right = null;
+        }
+        container[side] = state.pendingId;
+        state.pendingId = null;
+        this._normalizeContainers();
+        this._emitChange();
+        this._triggerRender();
+    }
+    /**
+     * Ensure there is always exactly one empty container at the end,
+     * and no completely empty containers in the middle.
+     */
+    _normalizeContainers() {
+        const state = this._state;
+        // Remove fully empty containers except the last one
+        state.containers = state.containers.filter(c => c.left !== null || c.right !== null);
+        state.containers.push({ left: null, right: null });
+    }
+    _cancelPending() {
+        this._state.pendingId = null;
+        this._triggerRender();
+    }
+    // ─── Render ─────────────────────────────────────────────────────────────
+    _renderDropContainer() {
+        const state = this._state;
+        const hasPending = state.pendingId !== null;
+        return html `
+      <div class="drop-container">
+        ${hasPending ? html `
+          <div class="pending-banner">
+            <span>${this.i18n.t('associate.selectSlot', { label: this._getLabel(state.pendingId) })}</span>
+            <button
+              type="button"
+              class="pending-cancel"
+              aria-label=${this.i18n.t('associate.cancel')}
+              @click=${(e) => { e.stopPropagation(); this._cancelPending(); }}
+            >×</button>
+          </div>
+        ` : nothing}
+        ${state.containers.map((container, i) => html `
+          <div class="associables-container">
+            <div
+              class="drop-slot ${container.left !== null ? 'filled' : hasPending ? 'droppable' : ''}"
+              @click=${container.left === null ? (e) => this._placeInSlot(i, 'left', e) : nothing}
+            >
+              ${container.left !== null
+            ? html `<span>${this._getLabel(container.left)}</span><button type="button" class="slot-remove" @click=${(e) => this._clearSlot(i, 'left', e)}>×</button>`
+            : html `<span>${this.i18n.t('associate.dropHere')}</span>`}
+            </div>
+            <span class="slot-arrow">↔</span>
+            <div
+              class="drop-slot ${container.right !== null ? 'filled' : hasPending ? 'droppable' : ''}"
+              @click=${container.right === null ? (e) => this._placeInSlot(i, 'right', e) : nothing}
+            >
+              ${container.right !== null
+            ? html `<span>${this._getLabel(container.right)}</span><button type="button" class="slot-remove" @click=${(e) => this._clearSlot(i, 'right', e)}>×</button>`
+            : html `<span>${this.i18n.t('associate.dropHere')}</span>`}
+            </div>
+          </div>
+        `)}
+      </div>
+    `;
+    }
+    updated(changedProperties) {
+        super.updated(changedProperties);
+        if (changedProperties.has('correctResponse')) {
+            // Skip re-parsing when the attribute change was triggered by our own _emitChange
+            if (this.correctResponse !== this._lastEmittedResponse) {
+                this._syncStateFromCorrectResponse();
+                this._triggerRender();
+            }
+        }
+    }
+    render() {
+        void this._renderTrigger;
+        return html `
+      <slot name="prompt"></slot>
+      <slot @slotchange=${this._onSlotChange}></slot>
+      ${this._setupDone ? this._renderDropContainer() : nothing}
+    `;
+    }
+}
+QtiAssociateInteractionEdit.styles = styles;
+__decorate([
+    property({ type: Number, attribute: 'max-associations' })
+], QtiAssociateInteractionEdit.prototype, "maxAssociations", void 0);
+__decorate([
+    property({ type: Number, attribute: 'min-associations' })
+], QtiAssociateInteractionEdit.prototype, "minAssociations", void 0);
+__decorate([
+    property({ type: Boolean })
+], QtiAssociateInteractionEdit.prototype, "shuffle", void 0);
+__decorate([
+    property({ type: String, attribute: 'correct-response' })
+], QtiAssociateInteractionEdit.prototype, "correctResponse", void 0);
+__decorate([
+    state()
+], QtiAssociateInteractionEdit.prototype, "_renderTrigger", void 0);
+if (!customElements.get('qti-associate-interaction')) {
+    customElements.define('qti-associate-interaction', QtiAssociateInteractionEdit);
+}

package/dist/components/qti-associate-interaction/qti-associate-interaction.schema.d.ts

@@ -0,0 +1,3 @@
+import type { NodeSpec } from 'prosemirror-model';
+export declare const qtiAssociateInteractionNodeSpec: NodeSpec;
+//# sourceMappingURL=qti-associate-interaction.schema.d.ts.map

package/dist/components/qti-associate-interaction/qti-associate-interaction.schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"qti-associate-interaction.schema.d.ts","sourceRoot":"","sources":["../../../src/components/qti-associate-interaction/qti-associate-interaction.schema.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAiB,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AAEjE,eAAO,MAAM,+BAA+B,EAAE,QA+C7C,CAAC"}

package/dist/components/qti-associate-interaction/qti-associate-interaction.schema.js

@@ -0,0 +1,52 @@
+export const qtiAssociateInteractionNodeSpec = {
+    group: 'block',
+    content: 'qtiPrompt? qtiSimpleAssociableChoice+',
+    attrs: {
+        maxAssociations: { default: 1 },
+        minAssociations: { default: 0 },
+        shuffle: { default: false },
+        class: { default: null },
+        correctResponse: { default: null },
+        responseIdentifier: { default: null }
+    },
+    parseDOM: [
+        {
+            tag: 'qti-associate-interaction',
+            getAttrs: (node) => {
+                if (!(node instanceof HTMLElement))
+                    return {};
+                const maxAssociations = node.getAttribute('max-associations');
+                const minAssociations = node.getAttribute('min-associations');
+                const className = node.getAttribute('class');
+                return {
+                    maxAssociations: maxAssociations ? parseInt(maxAssociations, 10) : 1,
+                    minAssociations: minAssociations ? parseInt(minAssociations, 10) : 0,
+                    shuffle: node.getAttribute('shuffle') === 'true',
+                    class: className || null,
+                    correctResponse: node.getAttribute('correct-response'),
+                    responseIdentifier: node.getAttribute('response-identifier')
+                };
+            }
+        }
+    ],
+    toDOM(node) {
+        const attrs = {
+            'max-associations': String(node.attrs.maxAssociations)
+        };
+        if (node.attrs.minAssociations > 0) {
+            attrs['min-associations'] = String(node.attrs.minAssociations);
+        }
+        if (node.attrs.shuffle) {
+            attrs['shuffle'] = 'true';
+        }
+        if (node.attrs.class)
+            attrs.class = node.attrs.class;
+        if (node.attrs.correctResponse)
+            attrs['correct-response'] = node.attrs.correctResponse;
+        if (node.attrs.responseIdentifier)
+            attrs['response-identifier'] = node.attrs.responseIdentifier;
+        return ['qti-associate-interaction', attrs, 0];
+    },
+    defining: true,
+    isolating: true
+};

package/dist/components/qti-associate-interaction/qti-associate-interaction.styles.d.ts

@@ -0,0 +1,4 @@
+import { type CSSResultGroup } from 'lit';
+declare const styles: CSSResultGroup;
+export default styles;
+//# sourceMappingURL=qti-associate-interaction.styles.d.ts.map

package/dist/components/qti-associate-interaction/qti-associate-interaction.styles.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"qti-associate-interaction.styles.d.ts","sourceRoot":"","sources":["../../../src/components/qti-associate-interaction/qti-associate-interaction.styles.ts"],"names":[],"mappings":"AAAA,OAAO,EAAO,KAAK,cAAc,EAAE,MAAM,KAAK,CAAC;AAI/C,QAAA,MAAM,MAAM,EAAE,cAoJb,CAAC;AAEF,eAAe,MAAM,CAAC"}

package/dist/components/qti-associate-interaction/qti-associate-interaction.styles.js

@@ -0,0 +1,152 @@
+import { css } from 'lit';
+import externalStyles from '@qti-components/associate-interaction/styles';
+const styles = [
+    externalStyles,
+    css `
+    :host {
+      display: block;
+      white-space: normal;
+    }
+
+    slot:not([name]) {
+      display: flex;
+      flex-wrap: wrap;
+      gap: 8px;
+      margin-top: 8px;
+    }
+
+    ::slotted(qti-simple-associable-choice) {
+      display: inline-flex;
+      align-items: center;
+      cursor: pointer;
+      border-radius: 4px;
+      padding: 4px 8px;
+      border: 1px solid var(--qti-border, #cbd5e1);
+      min-height: 2rem;
+      min-width: 10rem;
+      box-sizing: border-box;
+      vertical-align: top;
+    }
+
+    ::slotted(qti-simple-associable-choice:hover) {
+      background: var(--qti-bg-hover, #f1f5f9);
+    }
+
+    .drop-container {
+      margin-top: 12px;
+      display: flex;
+      flex-direction: column;
+      gap: 6px;
+    }
+
+    .associables-container {
+      display: flex;
+      align-items: center;
+      gap: 8px;
+    }
+
+    .drop-slot {
+      flex: 1;
+      min-height: 2rem;
+      padding: 4px 8px;
+      border: 1px dashed var(--qti-border, #cbd5e1);
+      border-radius: 4px;
+      background: #f8fafc;
+      font-size: 0.875em;
+      color: var(--qti-text-muted, #94a3b8);
+      display: flex;
+      align-items: center;
+      cursor: pointer;
+      transition: background 0.15s, border-color 0.15s;
+      user-select: none;
+    }
+
+    .drop-slot:hover {
+      background: var(--qti-bg-hover, #f1f5f9);
+      border-color: var(--qti-border-focus, #94a3b8);
+    }
+
+    .drop-slot.droppable {
+      border-color: var(--qti-border-warning, #f59e0b);
+      background: var(--qti-bg-warning, #fef3c7);
+      color: var(--qti-text-warning, #92400e);
+    }
+
+    .drop-slot.filled {
+      border-style: solid;
+      border-color: var(--qti-border-success, #22c55e);
+      background: var(--qti-bg-success, #dcfce7);
+      color: var(--qti-text-success, #166534);
+      cursor: default;
+    }
+
+    .drop-slot.filled:hover {
+      background: #bbf7d0;
+      border-color: #16a34a;
+    }
+
+    .slot-arrow {
+      color: var(--qti-text-muted, #94a3b8);
+      flex-shrink: 0;
+    }
+
+    .slot-remove {
+      display: inline-flex;
+      align-items: center;
+      justify-content: center;
+      width: 16px;
+      height: 16px;
+      margin-left: auto;
+      padding: 0;
+      border: none;
+      background: transparent;
+      cursor: pointer;
+      border-radius: 50%;
+      font-size: 13px;
+      line-height: 1;
+      color: inherit;
+      opacity: 0.6;
+      flex-shrink: 0;
+    }
+
+    .slot-remove:hover {
+      opacity: 1;
+      background: rgba(0, 0, 0, 0.1);
+    }
+
+    .pending-banner {
+      display: flex;
+      align-items: center;
+      gap: 8px;
+      padding: 4px 10px;
+      background: var(--qti-bg-warning, #fef3c7);
+      border: 1px dashed var(--qti-border-warning, #f59e0b);
+      border-radius: 4px;
+      font-size: 0.85em;
+      color: var(--qti-text-warning, #92400e);
+    }
+
+    .pending-cancel {
+      display: inline-flex;
+      align-items: center;
+      justify-content: center;
+      width: 18px;
+      height: 18px;
+      padding: 0;
+      border: none;
+      background: transparent;
+      cursor: pointer;
+      border-radius: 50%;
+      font-size: 14px;
+      line-height: 1;
+      color: inherit;
+      opacity: 0.6;
+    }
+
+    .pending-cancel:hover {
+      opacity: 1;
+      background: rgba(0, 0, 0, 0.1);
+    }
+  `
+];
+export default styles;

package/dist/composer/handler.d.ts

@@ -0,0 +1,3 @@
+import type { InteractionComposerHandler } from '@qti-editor/interaction-shared/composer/types.js';
+export declare const associateComposerHandler: InteractionComposerHandler;
+//# sourceMappingURL=handler.d.ts.map

package/dist/composer/handler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"handler.d.ts","sourceRoot":"","sources":["../../src/composer/handler.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,kDAAkD,CAAC;AAEnG,eAAO,MAAM,wBAAwB,EAAE,0BAGtC,CAAC"}

package/dist/composer/handler.js

@@ -0,0 +1,6 @@
+import { composeAssociateInteractionElement } from '../components/qti-associate-interaction/qti-associate-interaction.compose.js';
+import { ASSOCIATE_INTERACTION_TAG } from './metadata.js';
+export const associateComposerHandler = {
+    tagName: ASSOCIATE_INTERACTION_TAG,
+    compose: composeAssociateInteractionElement,
+};

package/dist/composer/metadata.d.ts

@@ -0,0 +1,21 @@
+export declare const ASSOCIATE_INTERACTION_TAG: "qti-associate-interaction";
+export declare const ASSOCIATE_INTERACTION_NODE_TYPE: "qtiAssociateInteraction";
+export declare const associateInteractionComposerMetadata: {
+    tagName: "qti-associate-interaction";
+    nodeTypeName: "qtiAssociateInteraction";
+    responseProcessingTemplate: string;
+    responseProcessing: {
+        templateUri: string;
+        internalKind: "map_response";
+        internalSourceXml: string;
+    };
+    editorOnlyAttributes: string[];
+    userEditableAttributes: string[];
+};
+export declare const associateNodeAttributePanelMetadataByNodeTypeName: {
+    [x: string]: {
+        nodeTypeName: "qtiAssociateInteraction";
+        editableAttributes: string[];
+    };
+};
+//# sourceMappingURL=metadata.d.ts.map

package/dist/composer/metadata.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"metadata.d.ts","sourceRoot":"","sources":["../../src/composer/metadata.ts"],"names":[],"mappings":"AAsBA,eAAO,MAAM,yBAAyB,EAAG,2BAAoC,CAAC;AAC9E,eAAO,MAAM,+BAA+B,EAAG,yBAAkC,CAAC;AAElF,eAAO,MAAM,oCAAoC;;;;;;;;;;;CAWV,CAAC;AAExC,eAAO,MAAM,iDAAiD;;;;;CAKR,CAAC"}

package/dist/composer/metadata.js

@@ -0,0 +1,38 @@
+const MAP_RESPONSE_TEMPLATE = 'https://purl.imsglobal.org/spec/qti/v3p0/rptemplates/map_response';
+const MAP_RESPONSE_INTERNAL_TEMPLATE = `
+  <qti-response-condition>
+    <qti-response-if>
+      <qti-is-null>
+        <qti-variable identifier="$responseIdentifier"/>
+      </qti-is-null>
+      <qti-set-outcome-value identifier="SCORE">
+        <qti-base-value base-type="float">0</qti-base-value>
+      </qti-set-outcome-value>
+    </qti-response-if>
+    <qti-response-else>
+      <qti-set-outcome-value identifier="SCORE">
+        <qti-map-response identifier="$responseIdentifier"/>
+      </qti-set-outcome-value>
+    </qti-response-else>
+  </qti-response-condition>
+`;
+export const ASSOCIATE_INTERACTION_TAG = 'qti-associate-interaction';
+export const ASSOCIATE_INTERACTION_NODE_TYPE = 'qtiAssociateInteraction';
+export const associateInteractionComposerMetadata = {
+    tagName: ASSOCIATE_INTERACTION_TAG,
+    nodeTypeName: ASSOCIATE_INTERACTION_NODE_TYPE,
+    responseProcessingTemplate: MAP_RESPONSE_TEMPLATE,
+    responseProcessing: {
+        templateUri: MAP_RESPONSE_TEMPLATE,
+        internalKind: 'map_response',
+        internalSourceXml: MAP_RESPONSE_INTERNAL_TEMPLATE,
+    },
+    editorOnlyAttributes: ['class'],
+    userEditableAttributes: ['maxAssociations', 'minAssociations', 'shuffle', 'correctResponse'],
+};
+export const associateNodeAttributePanelMetadataByNodeTypeName = {
+    [ASSOCIATE_INTERACTION_NODE_TYPE.toLowerCase()]: {
+        nodeTypeName: ASSOCIATE_INTERACTION_NODE_TYPE,
+        editableAttributes: associateInteractionComposerMetadata.userEditableAttributes,
+    },
+};

package/dist/descriptor.d.ts

@@ -0,0 +1,31 @@
+export declare const associateInteractionDescriptor: {
+    tagName: string;
+    nodeTypeName: string;
+    nodeSpecs: {
+        name: string;
+        spec: import("prosemirror-model").NodeSpec;
+    }[];
+    insertCommand: import("prosemirror-state").Command;
+    keyboardShortcut: string;
+    enterCommand: import("prosemirror-state").Command;
+    composerMetadata: {
+        tagName: "qti-associate-interaction";
+        nodeTypeName: "qtiAssociateInteraction";
+        responseProcessingTemplate: string;
+        responseProcessing: {
+            templateUri: string;
+            internalKind: "map_response";
+            internalSourceXml: string;
+        };
+        editorOnlyAttributes: string[];
+        userEditableAttributes: string[];
+    };
+    composerHandler: import("@qti-editor/interfaces").InteractionComposerHandler;
+    attributePanelMetadata: {
+        [x: string]: {
+            nodeTypeName: "qtiAssociateInteraction";
+            editableAttributes: string[];
+        };
+    };
+};
+//# sourceMappingURL=descriptor.d.ts.map

package/dist/descriptor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"descriptor.d.ts","sourceRoot":"","sources":["../src/descriptor.ts"],"names":[],"mappings":"AAeA,eAAO,MAAM,8BAA8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgBV,CAAC"}

package/dist/descriptor.js

@@ -0,0 +1,22 @@
+import { qtiPromptNodeSpec, qtiPromptParagraphNodeSpec, qtiSimpleAssociableChoiceNodeSpec, qtiSimpleAssociableChoiceParagraphNodeSpec, } from '@qti-editor/interaction-shared';
+import { insertAssociateInteraction, qtiAssociateEnterCommand } from './components/qti-associate-interaction/qti-associate-interaction.commands.js';
+import { qtiAssociateInteractionNodeSpec } from './components/qti-associate-interaction/qti-associate-interaction.schema.js';
+import { associateInteractionComposerMetadata, associateNodeAttributePanelMetadataByNodeTypeName } from './composer/metadata.js';
+import { associateComposerHandler } from './composer/handler.js';
+export const associateInteractionDescriptor = {
+    tagName: 'qti-associate-interaction',
+    nodeTypeName: 'qtiAssociateInteraction',
+    nodeSpecs: [
+        { name: 'qtiAssociateInteraction', spec: qtiAssociateInteractionNodeSpec },
+        { name: 'qtiPrompt', spec: qtiPromptNodeSpec },
+        { name: 'qtiPromptParagraph', spec: qtiPromptParagraphNodeSpec },
+        { name: 'qtiSimpleAssociableChoice', spec: qtiSimpleAssociableChoiceNodeSpec },
+        { name: 'qtiSimpleAssociableChoiceParagraph', spec: qtiSimpleAssociableChoiceParagraphNodeSpec },
+    ],
+    insertCommand: insertAssociateInteraction,
+    keyboardShortcut: 'Mod-Shift-a',
+    enterCommand: qtiAssociateEnterCommand,
+    composerMetadata: associateInteractionComposerMetadata,
+    composerHandler: associateComposerHandler,
+    attributePanelMetadata: associateNodeAttributePanelMetadataByNodeTypeName,
+};

package/dist/extensions/correct-response.d.ts

@@ -0,0 +1,13 @@
+import { type Extension } from 'prosekit/core';
+/**
+ * Event name for associate pair changes.
+ */
+export declare const ASSOCIATE_PAIR_CHANGE_EVENT = "associate-pair-change";
+/**
+ * Creates a ProseMirror extension that persists associate interaction correct responses.
+ *
+ * When pairs change, this extension serializes them to JSON and updates the
+ * interaction node's correctResponse attribute.
+ */
+export declare function defineAssociateCorrectResponseExtension(): Extension;
+//# sourceMappingURL=correct-response.d.ts.map

package/dist/extensions/correct-response.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"correct-response.d.ts","sourceRoot":"","sources":["../../src/extensions/correct-response.ts"],"names":[],"mappings":"AAAA,OAAO,EAAgB,KAAK,SAAS,EAAE,MAAM,eAAe,CAAC;AAQ7D;;GAEG;AACH,eAAO,MAAM,2BAA2B,0BAA0B,CAAC;AAyBnE;;;;;GAKG;AACH,wBAAgB,uCAAuC,IAAI,SAAS,CAmCnE"}

package/dist/extensions/correct-response.js

@@ -0,0 +1,62 @@
+import { definePlugin } from 'prosekit/core';
+import { Plugin, PluginKey } from 'prosekit/pm/state';
+const associateCorrectResponsePluginKey = new PluginKey('associate-correct-response');
+/**
+ * Event name for associate pair changes.
+ */
+export const ASSOCIATE_PAIR_CHANGE_EVENT = 'associate-pair-change';
+/**
+ * Finds the ProseMirror node position for an associate interaction element.
+ */
+function findInteractionNodePos(view, interactionElement) {
+    const { state } = view;
+    let foundPos = null;
+    state.doc.descendants((node, pos) => {
+        if (foundPos !== null)
+            return false;
+        if (node.type.name === 'qtiAssociateInteraction') {
+            const domNode = view.nodeDOM(pos);
+            if (domNode === interactionElement || (domNode && domNode.contains(interactionElement))) {
+                foundPos = pos;
+                return false;
+            }
+        }
+        return true;
+    });
+    return foundPos;
+}
+/**
+ * Creates a ProseMirror extension that persists associate interaction correct responses.
+ *
+ * When pairs change, this extension serializes them to JSON and updates the
+ * interaction node's correctResponse attribute.
+ */
+export function defineAssociateCorrectResponseExtension() {
+    return definePlugin(() => new Plugin({
+        key: associateCorrectResponsePluginKey,
+        view(view) {
+            const handlePairChange = (event) => {
+                const customEvent = event;
+                const interactionElement = customEvent.target;
+                if (!interactionElement.matches('qti-associate-interaction'))
+                    return;
+                const { pairs } = customEvent.detail;
+                const correctResponse = pairs.length > 0 ? JSON.stringify(pairs) : null;
+                const pos = findInteractionNodePos(view, interactionElement);
+                if (pos === null)
+                    return;
+                const { state, dispatch } = view;
+                const node = state.doc.nodeAt(pos);
+                if (!node)
+                    return;
+                dispatch(state.tr.setNodeMarkup(pos, undefined, { ...node.attrs, correctResponse }));
+            };
+            view.dom.addEventListener(ASSOCIATE_PAIR_CHANGE_EVENT, handlePairChange);
+            return {
+                destroy() {
+                    view.dom.removeEventListener(ASSOCIATE_PAIR_CHANGE_EVENT, handlePairChange);
+                },
+            };
+        },
+    }));
+}

package/dist/extensions/index.d.ts

@@ -0,0 +1,2 @@
+export { defineAssociateCorrectResponseExtension, ASSOCIATE_PAIR_CHANGE_EVENT, } from './correct-response.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/extensions/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/extensions/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,uCAAuC,EACvC,2BAA2B,GAC5B,MAAM,uBAAuB,CAAC"}

package/dist/extensions/index.js

@@ -0,0 +1 @@
+export { defineAssociateCorrectResponseExtension, ASSOCIATE_PAIR_CHANGE_EVENT, } from './correct-response.js';

package/dist/index.d.ts

@@ -0,0 +1,9 @@
+export * from './components/qti-associate-interaction/qti-associate-interaction.js';
+export * from './components/qti-associate-interaction/qti-associate-interaction.schema.js';
+export * from './components/qti-associate-interaction/qti-associate-interaction.commands.js';
+export * from './components/qti-associate-interaction/qti-associate-interaction.compose.js';
+export * from './extensions/index.js';
+export * from './composer/metadata.js';
+export * from './composer/handler.js';
+export * from './descriptor.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,qEAAqE,CAAC;AACpF,cAAc,4EAA4E,CAAC;AAC3F,cAAc,8EAA8E,CAAC;AAC7F,cAAc,6EAA6E,CAAC;AAE5F,cAAc,uBAAuB,CAAC;AAEtC,cAAc,wBAAwB,CAAC;AACvC,cAAc,uBAAuB,CAAC;AACtC,cAAc,iBAAiB,CAAC"}

package/dist/index.js

@@ -0,0 +1,8 @@
+export * from './components/qti-associate-interaction/qti-associate-interaction.js';
+export * from './components/qti-associate-interaction/qti-associate-interaction.schema.js';
+export * from './components/qti-associate-interaction/qti-associate-interaction.commands.js';
+export * from './components/qti-associate-interaction/qti-associate-interaction.compose.js';
+export * from './extensions/index.js';
+export * from './composer/metadata.js';
+export * from './composer/handler.js';
+export * from './descriptor.js';

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "@qti-editor/interaction-associate",
+  "description": "QTI associate interaction schemas, components, commands, and composer",
+  "version": "0.1.0",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./*": {
+      "types": "./dist/*",
+      "default": "./dist/*"
+    }
+  },
+  "scripts": {
+    "typecheck": "tsc --noEmit",
+    "build": "tsc",
+    "clean": "rm -rf dist"
+  },
+  "dependencies": {
+    "@qti-components/associate-interaction": "^1.1.3",
+    "@qti-components/interactions": "1.10.1",
+    "@qti-components/utilities": "1.3.2",
+    "@qti-editor/interaction-shared": "workspace:*",
+    "@qti-editor/interfaces": "workspace:*"
+  },
+  "peerDependencies": {
+    "lit": "^3.3.1"
+  },
+  "devDependencies": {
+    "lit": "^3.3.2",
+    "prosemirror-commands": "^1.7.1",
+    "prosemirror-model": "^1.25.4",
+    "prosemirror-state": "^1.4.4"
+  },
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public"
+  }
+}