@conform-ed/qti-react 0.0.16 → 0.0.18

package/dist/index.d.ts

@@ -2,6 +2,7 @@ export declare const qtiReactPackageName = "@conform-ed/qti-react";
 export { v0ContentModel, v0InteractionKinds, isAllowedFlowElement, isInteractionKind, sanitizeAttributes, type ContentModel, type V0InteractionKind, } from "./content-model";
 export { foldString, mapResponse, matchCorrect, mapResponsePoint, scoreResponse } from "./response-processing";
 export { assessmentItemViewFromNormalized, assessmentTestViewFromNormalized, stimulusContentFromNormalized, } from "./normalized-item";
+export { referenceInteractionKinds, reportItemCapability, type ItemCapabilityOptions } from "./item-capability";
 export { formatPoint, parseCoords, parsePoint, pointInShape, type Point, type QtiShape } from "./graphic";
 export { applyCorrectResponseOverrides, collectRpIssues, collectTemplateIssues, executeResponseProcessing, executeTemplateProcessing, mulberry32, resolveTemplate, } from "./rp";
 export type { CustomOperatorImplementation, InterpolationTableEntryView, InterpolationTableView, MatchTableEntryView, MatchTableView, MaybeRpValue, OutcomeDeclarationView, OutcomeValue, ResponseNormalization, ResponseProcessingContext, ResponseProcessingResult, ResponseProcessingView, RpConditionBranch, RpExpressionView, RpRecordField, RpRuleView, RpScalar, RpValue, TemplateConditionBranch, TemplateDeclarationView, TemplateProcessingContext, TemplateProcessingResult, TemplateProcessingView, TemplateRuleView, } from "./rp";

package/dist/index.js

@@ -2930,6 +2930,127 @@ function collectTemplateIssues(view, options) {
   walkRules(view.rules);
   return issues;
 }
+// src/item-capability.ts
+var feedbackKinds = new Set(["feedbackInline", "feedbackBlock"]);
+var templateContentKinds = new Set(["templateInline", "templateBlock"]);
+var intrinsicLeafKinds = new Set(["text", "printedVariable"]);
+function isFeedbackNode(node) {
+  return feedbackKinds.has(node.kind);
+}
+function isTemplateContentNode(node) {
+  return templateContentKinds.has(node.kind);
+}
+function isInteractionNode(node) {
+  return node.kind !== "xml" && typeof node.responseIdentifier === "string";
+}
+function reportItemCapability(item, options) {
+  const model = options.model ?? v0ContentModel;
+  const customOperatorClasses = options.customOperatorClasses ?? new Set;
+  const issues = [];
+  const seen = new Set;
+  function report(issue) {
+    const dedupeKey = `${issue.type}:${issue.name}:${issue.responseIdentifier ?? ""}`;
+    if (!seen.has(dedupeKey)) {
+      seen.add(dedupeKey);
+      issues.push(issue);
+    }
+  }
+  function walk(node) {
+    if (isFeedbackNode(node) || isTemplateContentNode(node) || node.kind === "rubricBlock") {
+      for (const child of node.content ?? []) {
+        walk(child);
+      }
+      return;
+    }
+    if (isInteractionNode(node)) {
+      if (!options.supportedInteractions.has(node.kind)) {
+        report({ type: "unsupported-interaction", name: node.kind, responseIdentifier: node.responseIdentifier });
+        return;
+      }
+      const schema = options.interactionSchemas?.get(node.kind);
+      if (schema) {
+        const parsed = schema.safeParse(node);
+        if (!parsed.success) {
+          const detail = parsed.error.issues[0]?.message;
+          report({
+            type: "invalid-interaction",
+            name: node.kind,
+            responseIdentifier: node.responseIdentifier,
+            ...detail !== undefined ? { detail } : {}
+          });
+        }
+      }
+      return;
+    }
+    if (node.kind === "xml") {
+      const xmlNode = node;
+      if (xmlNode.name === model.mathRoot) {
+        return;
+      }
+      if (!isAllowedFlowElement(model, xmlNode.name)) {
+        report({ type: "unsupported-element", name: xmlNode.name });
+      }
+      for (const child of xmlNode.children ?? []) {
+        walk(child);
+      }
+      return;
+    }
+    if (intrinsicLeafKinds.has(node.kind)) {
+      return;
+    }
+    report({ type: "unsupported-element", name: node.kind });
+  }
+  for (const node of item.itemBody.content ?? []) {
+    walk(node);
+  }
+  for (const ref of item.assessmentStimulusRefs ?? []) {
+    const stimulus = options.resolveStimulus?.(ref) ?? null;
+    if (stimulus === null) {
+      report({ type: "unsupported-element", name: "assessmentStimulusRef", detail: ref.href });
+      continue;
+    }
+    for (const node of stimulus.content) {
+      walk(node);
+    }
+  }
+  for (const feedback of item.modalFeedbacks ?? []) {
+    for (const child of feedback.content ?? []) {
+      walk(child);
+    }
+  }
+  for (const issue of collectRpIssues(item.responseProcessing, {
+    customOperatorClasses,
+    outcomeDeclarations: item.outcomeDeclarations ?? []
+  })) {
+    report(issue);
+  }
+  for (const issue of collectTemplateIssues(item.templateProcessing, { customOperatorClasses })) {
+    report(issue);
+  }
+  return { deliverable: issues.length === 0, issues };
+}
+var referenceInteractionKinds = [
+  "associateInteraction",
+  "choiceInteraction",
+  "drawingInteraction",
+  "endAttemptInteraction",
+  "extendedTextInteraction",
+  "gapMatchInteraction",
+  "graphicAssociateInteraction",
+  "graphicGapMatchInteraction",
+  "graphicOrderInteraction",
+  "hotspotInteraction",
+  "hottextInteraction",
+  "inlineChoiceInteraction",
+  "matchInteraction",
+  "mediaInteraction",
+  "orderInteraction",
+  "positionObjectStage",
+  "selectPointInteraction",
+  "sliderInteraction",
+  "textEntryInteraction",
+  "uploadInteraction"
+];
 // src/response-validity.ts
 var countConstraintKinds = ["minChoices", "maxChoices", "minAssociations", "maxAssociations", "minStrings"];
 function collectInteractionConstraints(content) {
@@ -4669,22 +4790,21 @@ function responseIncludes(value, optionIdentifier) {
 function isCorrectOption(declaration, optionIdentifier) {
   return Boolean(declaration?.correctResponse?.values.some((entry) => entry.value === optionIdentifier));
 }
-function isInteractionNode(node) {
+function isInteractionNode2(node) {
   return node.kind !== "xml" && typeof node.responseIdentifier === "string";
 }
-var feedbackKinds = new Set(["feedbackInline", "feedbackBlock"]);
-function isFeedbackNode(node) {
-  return feedbackKinds.has(node.kind);
+var feedbackKinds2 = new Set(["feedbackInline", "feedbackBlock"]);
+function isFeedbackNode2(node) {
+  return feedbackKinds2.has(node.kind);
 }
-var templateContentKinds = new Set(["templateInline", "templateBlock"]);
-function isTemplateContentNode(node) {
-  return templateContentKinds.has(node.kind);
+var templateContentKinds2 = new Set(["templateInline", "templateBlock"]);
+function isTemplateContentNode2(node) {
+  return templateContentKinds2.has(node.kind);
 }
 function templateVisible(value, view) {
   const matched = Array.isArray(value) ? value.includes(view.identifier) : value === view.identifier;
   return matched !== (view.showHide === "hide");
 }
-var intrinsicLeafKinds = new Set(["text", "printedVariable"]);
 function createStaticStore(outcomes) {
   const snapshot = {
     responses: {},
@@ -4782,13 +4902,13 @@ function createQtiRuntime(config) {
     if (override) {
       return createElement(Fragment, { key }, override(node, key));
     }
-    if (isInteractionNode(node)) {
+    if (isInteractionNode2(node)) {
       if (descriptorsByKind.has(node.kind) && config.skin[node.kind]) {
         return createElement(InteractionHost, { key, node });
       }
       return renderUnsupported(node, key);
     }
-    if (isFeedbackNode(node)) {
+    if (isFeedbackNode2(node)) {
       return createElement(FeedbackHost, {
         key,
         feedback: node,
@@ -4796,7 +4916,7 @@ function createQtiRuntime(config) {
         overrides
       });
     }
-    if (isTemplateContentNode(node)) {
+    if (isTemplateContentNode2(node)) {
       return createElement(TemplateContentHost, {
         key,
         view: node,
@@ -5039,91 +5159,15 @@ function createQtiRuntime(config) {
     return catalogIdref !== undefined ? catalogSupports.get(catalogIdref) ?? noSupports : noSupports;
   }
   function canDeliver(item) {
-    const issues = [];
-    const seen = new Set;
-    function report(issue) {
-      const dedupeKey = `${issue.type}:${issue.name}:${issue.responseIdentifier ?? ""}`;
-      if (!seen.has(dedupeKey)) {
-        seen.add(dedupeKey);
-        issues.push(issue);
-      }
-    }
-    function walk(node) {
-      if (isFeedbackNode(node) || isTemplateContentNode(node) || node.kind === "rubricBlock") {
-        for (const child of node.content ?? []) {
-          walk(child);
-        }
-        return;
-      }
-      if (isInteractionNode(node)) {
-        const descriptor = descriptorsByKind.get(node.kind);
-        if (!descriptor || !config.skin[node.kind]) {
-          report({
-            type: "unsupported-interaction",
-            name: node.kind,
-            responseIdentifier: node.responseIdentifier
-          });
-          return;
-        }
-        const parsed = descriptor.schema.safeParse(node);
-        if (!parsed.success) {
-          const detail = parsed.error.issues[0]?.message;
-          report({
-            type: "invalid-interaction",
-            name: node.kind,
-            responseIdentifier: node.responseIdentifier,
-            ...detail !== undefined ? { detail } : {}
-          });
-        }
-        return;
-      }
-      if (node.kind === "xml") {
-        const xmlNode = node;
-        if (xmlNode.name === model.mathRoot) {
-          return;
-        }
-        if (!isAllowedFlowElement(model, xmlNode.name)) {
-          report({ type: "unsupported-element", name: xmlNode.name });
-        }
-        for (const child of xmlNode.children ?? []) {
-          walk(child);
-        }
-        return;
-      }
-      if (intrinsicLeafKinds.has(node.kind)) {
-        return;
-      }
-      report({ type: "unsupported-element", name: node.kind });
-    }
-    for (const node of item.itemBody.content ?? []) {
-      walk(node);
-    }
-    for (const ref of item.assessmentStimulusRefs ?? []) {
-      const stimulus = config.resolveStimulus?.(ref) ?? null;
-      if (stimulus === null) {
-        report({ type: "unsupported-element", name: "assessmentStimulusRef", detail: ref.href });
-        continue;
-      }
-      for (const node of stimulus.content) {
-        walk(node);
-      }
-    }
-    for (const feedback of item.modalFeedbacks ?? []) {
-      for (const child of feedback.content ?? []) {
-        walk(child);
-      }
-    }
-    const customOperatorClasses = new Set(Object.keys(config.customOperators ?? {}));
-    for (const issue of collectRpIssues(item.responseProcessing, {
-      customOperatorClasses,
-      outcomeDeclarations: item.outcomeDeclarations ?? []
-    })) {
-      report(issue);
-    }
-    for (const issue of collectTemplateIssues(item.templateProcessing, { customOperatorClasses })) {
-      report(issue);
-    }
-    return { deliverable: issues.length === 0, issues };
+    const supportedInteractions = new Set([...descriptorsByKind.keys()].filter((kind) => Boolean(config.skin[kind])));
+    const interactionSchemas = new Map([...descriptorsByKind].map(([kind, descriptor]) => [kind, descriptor.schema]));
+    return reportItemCapability(item, {
+      supportedInteractions,
+      interactionSchemas,
+      model,
+      customOperatorClasses: new Set(Object.keys(config.customOperators ?? {})),
+      ...config.resolveStimulus !== undefined ? { resolveStimulus: config.resolveStimulus } : {}
+    });
   }
   return { ItemRenderer, ContentRenderer, useAttempt, useCatalogSupports, canDeliver };
 }
@@ -6758,7 +6802,9 @@ export {
   resolveTemplate,
   resolvePnpActivation,
   resolveCatalogSupports,
+  reportItemCapability,
   referenceSkin,
+  referenceInteractionKinds,
   qtiReactPackageName,
   qtiCoreInteractions,
   positionObjectStage,

package/dist/item-capability.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Headless capability gate (ADR-0003): "can a runtime that supports `supportedInteractions`
+ * deliver this item, and if not, why" — extracted from the React runtime's `canDeliver`
+ * so server-side callers (e.g. an ingest pipeline) can reach the *same* decision without
+ * importing React. The React runtime delegates to this, passing the interaction set its
+ * descriptors + skins cover; a headless caller passes the set its delivery supports.
+ *
+ * This module is React-free by construction (content-model + RP collectors only; the view
+ * shapes are type-only imports), so it ships through the `@conform-ed/qti-react/headless`
+ * entry alongside the normalize → view adapters.
+ */
+import type { ZodType } from "zod";
+import type { CapabilityReport } from "./capability";
+import { type ContentModel } from "./content-model";
+import type { AssessmentItemView, AssessmentStimulusRefView, StimulusContentView } from "./runtime";
+export interface ItemCapabilityOptions {
+    /** Interaction kinds the target runtime can render (descriptor + skin both present). */
+    readonly supportedInteractions: ReadonlySet<string>;
+    /** Content model deciding the flow-element allowlist + math root; defaults to v0. */
+    readonly model?: ContentModel;
+    /** Custom-operator classes the target runtime registers (for RP capability). */
+    readonly customOperatorClasses?: ReadonlySet<string>;
+    /** Resolver for shared-stimulus refs; unresolved refs are not deliverable. */
+    readonly resolveStimulus?: (ref: AssessmentStimulusRefView) => StimulusContentView | null;
+    /**
+     * Optional per-kind schemas for the stricter `invalid-interaction` check. The React
+     * runtime supplies its descriptor schemas; a headless caller that has already validated
+     * structure (e.g. against the qti-xml contracts schema) can omit them.
+     */
+    readonly interactionSchemas?: ReadonlyMap<string, ZodType>;
+}
+/**
+ * Report whether `item` can be delivered by a runtime with the given capabilities, and
+ * every reason it cannot. Pure and React-free; the React runtime's `canDeliver` is a thin
+ * wrapper over this.
+ */
+export declare function reportItemCapability(item: AssessmentItemView, options: ItemCapabilityOptions): CapabilityReport;
+/**
+ * Interaction kinds the bundled reference skin renders — the default "supported set" for
+ * callers that deliver with the reference skin. Kept in parity with the reference skin by
+ * a test; pass an explicit set to `reportItemCapability` for a custom delivery surface.
+ */
+export declare const referenceInteractionKinds: readonly string[];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@conform-ed/qti-react",
-  "version": "0.0.16",
+  "version": "0.0.18",
   "files": [
     "src",
     "dist"
@@ -9,12 +9,18 @@
   "module": "src/index.ts",
   "exports": {
     ".": {
+      "development": "./src/index.ts",
       "types": "./dist/index.d.ts",
       "import": "./dist/index.js"
+    },
+    "./headless": {
+      "development": "./src/headless.ts",
+      "types": "./dist/headless.d.ts",
+      "import": "./dist/headless.js"
     }
   },
   "scripts": {
-    "build": "bun build ./src/index.ts --outdir dist --format esm --target browser --external react --external react-dom --external zod && tsgo -p tsconfig.build.json",
+    "build": "bun build ./src/index.ts ./src/headless.ts --outdir dist --format esm --target browser --external react --external react-dom --external zod && tsgo -p tsconfig.build.json",
     "format": "oxfmt --config ../../.oxfmtrc.jsonc --check .",
     "lint": "oxlint --config ../../.oxlintrc.jsonc .",
     "test": "bun test",
@@ -24,8 +30,8 @@
     "xspattern": "^3.1.0"
   },
   "devDependencies": {
-    "@conform-ed/contracts": "0.0.16",
-    "@conform-ed/qti-xml": "0.0.13",
+    "@conform-ed/contracts": "0.0.18",
+    "@conform-ed/qti-xml": "0.0.18",
     "@types/react": "^19.2.17",
     "@types/react-dom": "^19",
     "happy-dom": "^20.10.2",

package/src/headless.ts

@@ -0,0 +1,26 @@
+/**
+ * Headless (React-free) surface of @conform-ed/qti-react: the normalize → view adapters
+ * and the capability gate, importable on a server (e.g. a QTI ingest pipeline) without
+ * pulling React. Exposed at `@conform-ed/qti-react/headless`; everything here is also
+ * re-exported from the package root for React consumers.
+ *
+ * Keep this entry free of React-coupled imports — only ./normalized-item and
+ * ./item-capability (value) plus type-only re-exports.
+ */
+
+export {
+  assessmentItemViewFromNormalized,
+  assessmentTestViewFromNormalized,
+  stimulusContentFromNormalized,
+} from "./normalized-item";
+export { referenceInteractionKinds, reportItemCapability, type ItemCapabilityOptions } from "./item-capability";
+export type { CapabilityIssue, CapabilityIssueType, CapabilityReport } from "./capability";
+export type {
+  AssessmentItemView,
+  AssessmentStimulusRefView,
+  BodyNode,
+  InteractionNode,
+  StimulusContentView,
+  XmlContentNode,
+} from "./runtime";
+export type { AssessmentTestView } from "./test";

package/src/index.ts

@@ -20,6 +20,8 @@ export {
   stimulusContentFromNormalized,
 } from "./normalized-item";
 
+export { referenceInteractionKinds, reportItemCapability, type ItemCapabilityOptions } from "./item-capability";
+
 export { formatPoint, parseCoords, parsePoint, pointInShape, type Point, type QtiShape } from "./graphic";
 
 export {

package/src/item-capability.ts

@@ -0,0 +1,211 @@
+/**
+ * Headless capability gate (ADR-0003): "can a runtime that supports `supportedInteractions`
+ * deliver this item, and if not, why" — extracted from the React runtime's `canDeliver`
+ * so server-side callers (e.g. an ingest pipeline) can reach the *same* decision without
+ * importing React. The React runtime delegates to this, passing the interaction set its
+ * descriptors + skins cover; a headless caller passes the set its delivery supports.
+ *
+ * This module is React-free by construction (content-model + RP collectors only; the view
+ * shapes are type-only imports), so it ships through the `@conform-ed/qti-react/headless`
+ * entry alongside the normalize → view adapters.
+ */
+
+import type { ZodType } from "zod";
+
+import type { CapabilityIssue, CapabilityReport } from "./capability";
+import { isAllowedFlowElement, v0ContentModel, type ContentModel } from "./content-model";
+import { collectRpIssues, collectTemplateIssues } from "./rp";
+import type {
+  AssessmentItemView,
+  AssessmentStimulusRefView,
+  BodyNode,
+  InteractionNode,
+  StimulusContentView,
+  XmlContentNode,
+} from "./runtime";
+
+const feedbackKinds = new Set(["feedbackInline", "feedbackBlock"]);
+const templateContentKinds = new Set(["templateInline", "templateBlock"]);
+
+/** Body node kinds that render without a descriptor, skin, or content-model entry. */
+const intrinsicLeafKinds = new Set(["text", "printedVariable"]);
+
+function isFeedbackNode(node: BodyNode): boolean {
+  return feedbackKinds.has(node.kind);
+}
+
+function isTemplateContentNode(node: BodyNode): boolean {
+  return templateContentKinds.has(node.kind);
+}
+
+/**
+ * An interaction node is any non-xml node carrying a `responseIdentifier` — including
+ * kinds this runtime has never heard of. The discriminator must not depend on the
+ * supported set, or unknown interactions would be indistinguishable from text.
+ */
+function isInteractionNode(node: BodyNode): node is InteractionNode {
+  return node.kind !== "xml" && typeof (node as { responseIdentifier?: unknown }).responseIdentifier === "string";
+}
+
+export interface ItemCapabilityOptions {
+  /** Interaction kinds the target runtime can render (descriptor + skin both present). */
+  readonly supportedInteractions: ReadonlySet<string>;
+  /** Content model deciding the flow-element allowlist + math root; defaults to v0. */
+  readonly model?: ContentModel;
+  /** Custom-operator classes the target runtime registers (for RP capability). */
+  readonly customOperatorClasses?: ReadonlySet<string>;
+  /** Resolver for shared-stimulus refs; unresolved refs are not deliverable. */
+  readonly resolveStimulus?: (ref: AssessmentStimulusRefView) => StimulusContentView | null;
+  /**
+   * Optional per-kind schemas for the stricter `invalid-interaction` check. The React
+   * runtime supplies its descriptor schemas; a headless caller that has already validated
+   * structure (e.g. against the qti-xml contracts schema) can omit them.
+   */
+  readonly interactionSchemas?: ReadonlyMap<string, ZodType>;
+}
+
+/**
+ * Report whether `item` can be delivered by a runtime with the given capabilities, and
+ * every reason it cannot. Pure and React-free; the React runtime's `canDeliver` is a thin
+ * wrapper over this.
+ */
+export function reportItemCapability(item: AssessmentItemView, options: ItemCapabilityOptions): CapabilityReport {
+  const model = options.model ?? v0ContentModel;
+  const customOperatorClasses = options.customOperatorClasses ?? new Set<string>();
+  const issues: CapabilityIssue[] = [];
+  const seen = new Set<string>();
+
+  function report(issue: CapabilityIssue): void {
+    const dedupeKey = `${issue.type}:${issue.name}:${issue.responseIdentifier ?? ""}`;
+
+    if (!seen.has(dedupeKey)) {
+      seen.add(dedupeKey);
+      issues.push(issue);
+    }
+  }
+
+  function walk(node: BodyNode): void {
+    if (isFeedbackNode(node) || isTemplateContentNode(node) || node.kind === "rubricBlock") {
+      for (const child of (node as unknown as { content?: readonly BodyNode[] }).content ?? []) {
+        walk(child);
+      }
+
+      return;
+    }
+
+    if (isInteractionNode(node)) {
+      if (!options.supportedInteractions.has(node.kind)) {
+        report({ type: "unsupported-interaction", name: node.kind, responseIdentifier: node.responseIdentifier });
+
+        return;
+      }
+
+      const schema = options.interactionSchemas?.get(node.kind);
+
+      if (schema) {
+        const parsed = schema.safeParse(node);
+
+        if (!parsed.success) {
+          const detail = parsed.error.issues[0]?.message;
+
+          report({
+            type: "invalid-interaction",
+            name: node.kind,
+            responseIdentifier: node.responseIdentifier,
+            ...(detail !== undefined ? { detail } : {}),
+          });
+        }
+      }
+
+      return;
+    }
+
+    if (node.kind === "xml") {
+      const xmlNode = node as XmlContentNode;
+
+      if (xmlNode.name === model.mathRoot) {
+        return;
+      }
+
+      if (!isAllowedFlowElement(model, xmlNode.name)) {
+        report({ type: "unsupported-element", name: xmlNode.name });
+      }
+
+      for (const child of xmlNode.children ?? []) {
+        walk(child);
+      }
+
+      return;
+    }
+
+    if (intrinsicLeafKinds.has(node.kind)) {
+      return;
+    }
+
+    report({ type: "unsupported-element", name: node.kind });
+  }
+
+  for (const node of item.itemBody.content ?? []) {
+    walk(node);
+  }
+
+  for (const ref of item.assessmentStimulusRefs ?? []) {
+    const stimulus = options.resolveStimulus?.(ref) ?? null;
+
+    if (stimulus === null) {
+      report({ type: "unsupported-element", name: "assessmentStimulusRef", detail: ref.href });
+      continue;
+    }
+
+    for (const node of stimulus.content) {
+      walk(node);
+    }
+  }
+
+  for (const feedback of item.modalFeedbacks ?? []) {
+    for (const child of feedback.content ?? []) {
+      walk(child);
+    }
+  }
+
+  for (const issue of collectRpIssues(item.responseProcessing, {
+    customOperatorClasses,
+    outcomeDeclarations: item.outcomeDeclarations ?? [],
+  })) {
+    report(issue);
+  }
+
+  for (const issue of collectTemplateIssues(item.templateProcessing, { customOperatorClasses })) {
+    report(issue);
+  }
+
+  return { deliverable: issues.length === 0, issues };
+}
+
+/**
+ * Interaction kinds the bundled reference skin renders — the default "supported set" for
+ * callers that deliver with the reference skin. Kept in parity with the reference skin by
+ * a test; pass an explicit set to `reportItemCapability` for a custom delivery surface.
+ */
+export const referenceInteractionKinds: readonly string[] = [
+  "associateInteraction",
+  "choiceInteraction",
+  "drawingInteraction",
+  "endAttemptInteraction",
+  "extendedTextInteraction",
+  "gapMatchInteraction",
+  "graphicAssociateInteraction",
+  "graphicGapMatchInteraction",
+  "graphicOrderInteraction",
+  "hotspotInteraction",
+  "hottextInteraction",
+  "inlineChoiceInteraction",
+  "matchInteraction",
+  "mediaInteraction",
+  "orderInteraction",
+  "positionObjectStage",
+  "selectPointInteraction",
+  "sliderInteraction",
+  "textEntryInteraction",
+  "uploadInteraction",
+];