@conform-ed/qti-react 0.0.12 → 0.0.14

package/dist/interactions/associate.d.ts

@@ -0,0 +1,2 @@
+import { type InteractionDescriptor } from "../runtime";
+export declare const associateInteraction: InteractionDescriptor<"associateInteraction">;

package/dist/interactions/choice.d.ts

@@ -0,0 +1,2 @@
+import { type InteractionDescriptor } from "../runtime";
+export declare const choiceInteraction: InteractionDescriptor<"choiceInteraction">;

package/dist/interactions/drawing.d.ts

@@ -0,0 +1,2 @@
+import { type InteractionDescriptor } from "../runtime";
+export declare const drawingInteraction: InteractionDescriptor<"drawingInteraction">;

package/dist/interactions/end-attempt.d.ts

@@ -0,0 +1,2 @@
+import { type InteractionDescriptor } from "../runtime";
+export declare const endAttemptInteraction: InteractionDescriptor<"endAttemptInteraction">;

package/dist/interactions/extended-text.d.ts

@@ -0,0 +1,2 @@
+import { type InteractionDescriptor } from "../runtime";
+export declare const extendedTextInteraction: InteractionDescriptor<"extendedTextInteraction">;

package/dist/interactions/gap-match.d.ts

@@ -0,0 +1,2 @@
+import { type InteractionDescriptor } from "../runtime";
+export declare const gapMatchInteraction: InteractionDescriptor<"gapMatchInteraction">;

package/dist/interactions/graphic.d.ts

@@ -0,0 +1,13 @@
+/**
+ * The graphic interaction family: descriptors share the object (stage image) and
+ * hotspot (shape/coords) schemas. Coordinates are numbers in image space, normalized
+ * upstream from the QTI coords attribute.
+ */
+import { type InteractionDescriptor } from "../runtime";
+export declare const hotspotInteraction: InteractionDescriptor<"hotspotInteraction">;
+export declare const graphicOrderInteraction: InteractionDescriptor<"graphicOrderInteraction">;
+export declare const graphicAssociateInteraction: InteractionDescriptor<"graphicAssociateInteraction">;
+export declare const graphicGapMatchInteraction: InteractionDescriptor<"graphicGapMatchInteraction">;
+export declare const selectPointInteraction: InteractionDescriptor<"selectPointInteraction">;
+/** The common single-interaction stage; multi-interaction stages fail validation. */
+export declare const positionObjectStage: InteractionDescriptor<"positionObjectStage">;

package/dist/interactions/hottext.d.ts

@@ -0,0 +1,2 @@
+import { type InteractionDescriptor } from "../runtime";
+export declare const hottextInteraction: InteractionDescriptor<"hottextInteraction">;

package/dist/interactions/index.d.ts

@@ -0,0 +1,18 @@
+import type { InteractionDescriptor } from "../runtime";
+export { associateInteraction } from "./associate";
+export { choiceInteraction } from "./choice";
+export { drawingInteraction } from "./drawing";
+export { endAttemptInteraction } from "./end-attempt";
+export { extendedTextInteraction } from "./extended-text";
+export { gapMatchInteraction } from "./gap-match";
+export { graphicAssociateInteraction, graphicGapMatchInteraction, graphicOrderInteraction, hotspotInteraction, positionObjectStage, selectPointInteraction, } from "./graphic";
+export { hottextInteraction } from "./hottext";
+export { inlineChoiceInteraction } from "./inline-choice";
+export { matchInteraction } from "./match";
+export { mediaInteraction } from "./media";
+export { orderInteraction } from "./order";
+export { sliderInteraction } from "./slider";
+export { textEntryInteraction } from "./text-entry";
+export { uploadInteraction } from "./upload";
+/** The interaction set conform-ed ships; consumers assemble these plus their extensions. */
+export declare const qtiCoreInteractions: readonly InteractionDescriptor[];

package/dist/interactions/inline-choice.d.ts

@@ -0,0 +1,2 @@
+import { type InteractionDescriptor } from "../runtime";
+export declare const inlineChoiceInteraction: InteractionDescriptor<"inlineChoiceInteraction">;

package/dist/interactions/match.d.ts

@@ -0,0 +1,2 @@
+import { type InteractionDescriptor } from "../runtime";
+export declare const matchInteraction: InteractionDescriptor<"matchInteraction">;

package/dist/interactions/media.d.ts

@@ -0,0 +1,2 @@
+import { type InteractionDescriptor } from "../runtime";
+export declare const mediaInteraction: InteractionDescriptor<"mediaInteraction">;

package/dist/interactions/order.d.ts

@@ -0,0 +1,2 @@
+import { type InteractionDescriptor } from "../runtime";
+export declare const orderInteraction: InteractionDescriptor<"orderInteraction">;

package/dist/interactions/slider.d.ts

@@ -0,0 +1,2 @@
+import { type InteractionDescriptor } from "../runtime";
+export declare const sliderInteraction: InteractionDescriptor<"sliderInteraction">;

package/dist/interactions/text-entry.d.ts

@@ -0,0 +1,2 @@
+import { type InteractionDescriptor } from "../runtime";
+export declare const textEntryInteraction: InteractionDescriptor<"textEntryInteraction">;

package/dist/interactions/upload.d.ts

@@ -0,0 +1,2 @@
+import { type InteractionDescriptor } from "../runtime";
+export declare const uploadInteraction: InteractionDescriptor<"uploadInteraction">;

package/dist/normalized-item.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Adapter from `@conform-ed/qti-xml`'s normalized assessment-item JSON (the contracts
+ * vocabulary) to the runtime's `AssessmentItemView`. Pure data reshaping with no
+ * qti-xml dependency. The contracts shapes and the runtime's descriptor shapes
+ * deliberately differ in places; this seam is where they reconcile:
+ *
+ * - bare-string text fragments become `{ kind: "text", value }` nodes
+ * - `hotTextInteraction`/`hotText` rename to the runtime's `hottextInteraction`/`hottext`
+ * - graphic stages: contract `image` xml nodes become `{ data, width, height, type }`
+ *   objects, and `coords` strings become number arrays (also in `areaMapping`)
+ * - `gapChoices` split into the runtime's `gapTexts` (gapMatch) / `gapImgs` (graphic)
+ * - media/upload/positionObjectStage flatten to the descriptor fields
+ * - processing trees: `children` → `expressions`, `actions` → `rules`,
+ *   `responseElseIf`/`templateElseIf` pluralize
+ *
+ * Used by the corpus delivery meter (ADR-0002) and by any consumer ingesting
+ * normalized XML.
+ */
+import type { AssessmentItemView } from "./runtime";
+import type { AssessmentTestView } from "./test";
+/**
+ * Reshape a normalized QTI document (the `normalizedDocument` from qti-xml validation)
+ * into an `AssessmentItemView`, or null when it is not an assessment item.
+ */
+export declare function assessmentItemViewFromNormalized(document: unknown): AssessmentItemView | null;
+/**
+ * Reshape a normalized QTI document into the Test Controller's `AssessmentTestView`,
+ * or null when it is not an assessment test.
+ */
+export declare function assessmentTestViewFromNormalized(document: unknown): AssessmentTestView | null;

package/dist/pci/index.d.ts

@@ -0,0 +1,6 @@
+export { pciResponseToValue, valueToPciResponse } from "./response";
+export { createPciModuleRegistry, type PciConfiguration, type PciInstance, type PciModule, type PciModuleRegistry, type PciModuleRegistryOptions, } from "./registry";
+export { serializePciMarkup } from "./markup";
+export { mountPci, type PciInteractionNode, type PciMountHandle, type PciMountOptions } from "./mount";
+export { portableCustomInteraction } from "./interaction";
+export { createPciSkin, type PciSkinOptions } from "./skin";

package/dist/pci/interaction.d.ts

@@ -0,0 +1,8 @@
+import { type InteractionDescriptor } from "../runtime";
+/**
+ * The PCI interaction descriptor. Deliberately NOT part of `qtiCoreInteractions`:
+ * delivering a PCI executes item-supplied JavaScript, so consumers opt in by adding
+ * this descriptor plus a skin from `createPciSkin` (ADR-0003 — the capability gate
+ * keeps PCI items undeliverable until then).
+ */
+export declare const portableCustomInteraction: InteractionDescriptor<"portableCustomInteraction">;

package/dist/pci/markup.d.ts

@@ -0,0 +1,10 @@
+/**
+ * PCI markup serialization: `qti-interaction-markup` content back to an HTML string
+ * for injection into the host container. PCI markup is module-owned — the module
+ * queries and mutates it directly — so unlike flow content it is not constrained to
+ * the content-model element allowlist. The serializer still strips what must never
+ * reach the DOM statically: event-handler attributes, script-scheme URLs, and
+ * `<script>` elements (modules bring behaviour through the registry, not markup).
+ */
+import type { BodyNode } from "../runtime";
+export declare function serializePciMarkup(nodes: ReadonlyArray<BodyNode | string> | undefined): string;

package/dist/pci/mount.d.ts

@@ -0,0 +1,50 @@
+/**
+ * The PCI mount lifecycle, framework-free (the React skin is a thin wrapper): resolve
+ * the module through the registry (declared interaction modules with primary →
+ * fallback paths, then the bare `module` name), inject the serialized markup, call
+ * `getInstance(dom, configuration, state)`, and hand back a handle the host uses to
+ * collect the response at submit time and to tear the instance down.
+ */
+import type { BodyNode } from "../runtime";
+import type { ResponseDeclarationView, ResponseValue } from "../types";
+import type { PciInstance, PciModuleRegistry } from "./registry";
+/** The adapter's shape for a `portableCustomInteraction` body node. */
+export interface PciInteractionNode {
+    readonly kind: "portableCustomInteraction";
+    readonly responseIdentifier: string;
+    readonly customInteractionTypeIdentifier: string;
+    readonly module?: string;
+    readonly class?: readonly string[];
+    readonly properties?: Readonly<Record<string, string>>;
+    readonly interactionMarkup?: {
+        readonly content?: ReadonlyArray<BodyNode | string>;
+    };
+    readonly interactionModules?: {
+        readonly primaryConfiguration?: string;
+        readonly modules?: ReadonlyArray<{
+            readonly id: string;
+            readonly primaryPath?: string;
+            readonly fallbackPath?: string;
+        }>;
+    };
+}
+export interface PciMountOptions {
+    readonly container: Element;
+    readonly node: PciInteractionNode;
+    readonly registry: PciModuleRegistry;
+    /** The bound response variable's declaration and current value (for `boundTo`). */
+    readonly declaration?: ResponseDeclarationView;
+    readonly boundValue?: ResponseValue;
+    /** A state string from a previous instance's getState() (session restore). */
+    readonly state?: string;
+    /** PCI `ondone`: the instance finished on its own and reports its response. */
+    readonly ondone?: (value: ResponseValue, state?: string) => void;
+}
+export interface PciMountHandle {
+    readonly instance: PciInstance;
+    /** The instance's current response as a runtime ResponseValue. */
+    readonly collectResponse: () => ResponseValue | undefined;
+    readonly getState: () => string | undefined;
+    readonly unmount: () => void;
+}
+export declare function mountPci(options: PciMountOptions): Promise<PciMountHandle>;

package/dist/pci/registry.d.ts

@@ -0,0 +1,53 @@
+/**
+ * The PCI Module Registry: PCI v1 modules are AMD (`define([deps], factory)`), so the
+ * registry provides a minimal AMD surface — source evaluation with a scoped `define`,
+ * dependency resolution among registered modules, the `qtiCustomInteractionContext`
+ * bridge (`register` keyed by typeIdentifier), and URL loading with primary → fallback
+ * candidates. PCI is a trust boundary: evaluating a module executes item-supplied
+ * code, which is why PCI support is opt-in and never part of `qtiCoreInteractions`.
+ */
+/** The configuration handed to `getInstance` (IMS PCI v1). */
+export interface PciConfiguration {
+    readonly properties: Readonly<Record<string, string>>;
+    readonly responseIdentifier?: string;
+    /** The bound response variable's current value in PCI JSON form. */
+    readonly boundTo?: Readonly<Record<string, unknown>>;
+    readonly status?: string;
+    readonly onready?: (instance: PciInstance, state?: string) => void;
+    readonly ondone?: (instance: PciInstance, response: unknown, state?: string, status?: string) => void;
+}
+export interface PciInstance {
+    readonly typeIdentifier?: string;
+    getResponse(): unknown;
+    getState?(): string;
+    /** Engine-invoked before the instance is unloaded (cleanup hook). */
+    oncompleted?(): void;
+}
+export interface PciModule {
+    readonly typeIdentifier?: string;
+    getInstance(dom: Element, configuration: PciConfiguration, state: string | undefined): PciInstance | undefined;
+}
+export interface PciModuleRegistryOptions {
+    /** Base for relative module paths (typically the item package root URL). */
+    readonly baseUrl?: string;
+    /** Module id → path overrides (a parsed `module_resolution.js` paths map). */
+    readonly paths?: Readonly<Record<string, string>>;
+    /** Source fetcher for URL loading; defaults to global fetch. */
+    readonly fetchText?: (url: string) => Promise<string>;
+}
+export interface PciModuleRegistry {
+    /** Evaluate AMD source text; its `define` registers under the given module id. */
+    readonly evaluate: (source: string, context: {
+        readonly id: string;
+    }) => void;
+    /** Register a prebuilt module directly (bundled PCIs, tests). */
+    readonly registerModule: (id: string, module: PciModule) => void;
+    /** Resolve by module id or by PCI typeIdentifier; undefined when unknown. */
+    readonly resolve: (id: string) => PciModule | undefined;
+    /**
+     * Load a module from candidate paths in order (primary → fallback), falling back to
+     * the registry's `paths` map when no candidates are given.
+     */
+    readonly load: (id: string, candidates: readonly string[]) => Promise<PciModule>;
+}
+export declare function createPciModuleRegistry(options?: PciModuleRegistryOptions): PciModuleRegistry;

package/dist/pci/response.d.ts

@@ -0,0 +1,11 @@
+/**
+ * PCI JSON ↔ ResponseValue conversion (IMS PCI v1 "JSON representation of variable
+ * values"). PCI instances exchange `{ base: { integer: 3 } }` / `{ list: ... }` /
+ * `{ record: [{ name, base }] }` shapes; the attempt store speaks string / string[] /
+ * record-object / null. Record fields keep their runtime type so `fieldValue` in
+ * response processing sees properly typed members.
+ */
+import type { ResponseDeclarationView, ResponseValue } from "../types";
+export declare function pciResponseToValue(json: unknown): ResponseValue;
+/** The current response in PCI JSON form — fed to `getInstance` as `boundTo`. */
+export declare function valueToPciResponse(value: ResponseValue, declaration: ResponseDeclarationView): unknown;

package/dist/pci/skin.d.ts

@@ -0,0 +1,12 @@
+/**
+ * The PCI host skin: a thin React wrapper over `mountPci`. It renders the container,
+ * mounts the module instance after first paint, registers a submit-time response
+ * collector with the attempt store, and tears the instance down on unmount. Module
+ * failures render an explicit error note — never a silent drop (ADR-0003).
+ */
+import type { InteractionSkin } from "../runtime";
+import type { PciModuleRegistry } from "./registry";
+export interface PciSkinOptions {
+    readonly registry: PciModuleRegistry;
+}
+export declare function createPciSkin(options: PciSkinOptions): InteractionSkin;

package/dist/reference-skin/associate.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Reference Skin for `associateInteraction` (ADR-0001): a pair builder — two selects
+ * over the same choice set, an "Add pair" button, and a removable list of the pairs
+ * built so far. Pairs are unordered (`pair` baseType); scoring handles reversal.
+ */
+import { type ReactNode } from "react";
+import type { InteractionRenderProps } from "../runtime";
+export declare function AssociateReferenceSkin(props: InteractionRenderProps): ReactNode;

package/dist/reference-skin/choice.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Reference Skin for `choiceInteraction` (ADR-0001): unstyled, semantic, a11y-correct.
+ * Native `<button>` elements carry the option prop-getters so Space/Enter activation is
+ * free; all visual state is exposed as data attributes for downstream styling.
+ */
+import { type ReactNode } from "react";
+import type { InteractionRenderProps } from "../runtime";
+export declare function ChoiceReferenceSkin(props: InteractionRenderProps): ReactNode;

package/dist/reference-skin/content.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Plain-text extraction for places where the DOM only accepts text (e.g. `<option>`
+ * children). Walks a BodyNode fragment and concatenates its text values.
+ */
+import type { BodyNode } from "../runtime";
+export declare function textOf(nodes: readonly BodyNode[] | undefined): string;

package/dist/reference-skin/drawing.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Reference Skin for `drawingInteraction` (ADR-0001): a canvas drawing surface over
+ * the stage image. The candidate draws freehand strokes with the pointer; the result
+ * is captured as a PNG data URL into the `file` response (the upload convention).
+ * Items using drawing are typically scored externally, not by client RP.
+ */
+import { type ReactNode } from "react";
+import type { InteractionRenderProps } from "../runtime";
+export declare function DrawingReferenceSkin(props: InteractionRenderProps): ReactNode;

package/dist/reference-skin/end-attempt.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Reference Skin for `endAttemptInteraction` (ADR-0001): a titled button that sets its
+ * boolean response true and ends the current attempt (hints, give-up, adaptive moves).
+ */
+import { type ReactNode } from "react";
+import type { InteractionRenderProps } from "../runtime";
+export declare function EndAttemptReferenceSkin(props: InteractionRenderProps): ReactNode;

package/dist/reference-skin/extended-text.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Reference Skin for `extendedTextInteraction` (ADR-0001): a controlled textarea.
+ */
+import { type ReactNode } from "react";
+import type { InteractionRenderProps } from "../runtime";
+export declare function ExtendedTextReferenceSkin(props: InteractionRenderProps): ReactNode;

package/dist/reference-skin/gap-match.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Reference Skin for `gapMatchInteraction` (ADR-0001): the interaction's flow content
+ * renders through the core walk with a `gap` override — each gap becomes a select over
+ * the gap texts. Choosing a gap text records the directedPair "GAPTEXT GAP".
+ */
+import { type ReactNode } from "react";
+import type { InteractionRenderProps } from "../runtime";
+export declare function GapMatchReferenceSkin(props: InteractionRenderProps): ReactNode;

package/dist/reference-skin/graphic-associate.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Reference Skin for `graphicAssociateInteraction` (ADR-0001): click two hotspots to
+ * connect them; connections draw as lines and list below with remove buttons. Pairs
+ * are unordered (`pair` baseType).
+ */
+import { type ReactNode } from "react";
+import type { InteractionRenderProps } from "../runtime";
+export declare function GraphicAssociateReferenceSkin(props: InteractionRenderProps): ReactNode;

package/dist/reference-skin/graphic-base.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Shared scaffolding for the graphic Reference Skins (ADR-0001): a stage (the image
+ * with an SVG overlay in image coordinates) plus QTI shape → SVG element mapping.
+ */
+import { type ReactNode, type SVGProps } from "react";
+import type { Point } from "../graphic";
+export interface ObjectView {
+    data: string;
+    width?: number;
+    height?: number;
+    type?: string;
+}
+export interface HotspotView {
+    identifier: string;
+    shape: string;
+    coords: readonly number[];
+    matchMax?: number;
+}
+/** The geometric center of a shape, for badges, lines, and placed images. */
+export declare function shapeCenter(shape: string, coords: readonly number[]): Point;
+/** Extra props a shape may carry, including data-* attributes. */
+export type ShapeProps = SVGProps<SVGElement> & {
+    [dataAttribute: `data-${string}`]: string | number | boolean;
+};
+/** Map a QTI (shape, coords) to an SVG element with the given extra props. */
+export declare function shapeElement(shape: string, coords: readonly number[], key: string, props: ShapeProps): ReactNode;
+export interface GraphicStageProps {
+    object: ObjectView;
+    resolveAsset: (href: string) => string;
+    interaction: string;
+    status: string;
+    /** Stage click in image coordinates (from the SVG overlay). */
+    onStageClick?: (point: Point) => void;
+    prompt?: ReactNode;
+    overlay?: ReactNode;
+    after?: ReactNode;
+}
+/** The image + coordinate-space SVG overlay every graphic interaction shares. */
+export declare function GraphicStage(props: GraphicStageProps): ReactNode;

package/dist/reference-skin/graphic-gap-match.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Reference Skin for `graphicGapMatchInteraction` (ADR-0001): pick a gap image from
+ * the tray, then click a hotspot to place it — no drag-and-drop. Placed images draw
+ * at the hotspot center; responses are directedPairs gapImg→hotspot.
+ */
+import { type ReactNode } from "react";
+import type { InteractionRenderProps } from "../runtime";
+export declare function GraphicGapMatchReferenceSkin(props: InteractionRenderProps): ReactNode;

package/dist/reference-skin/graphic-order.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Reference Skin for `graphicOrderInteraction` (ADR-0001): click hotspots in sequence;
+ * each selected hotspot shows its position badge. Clicking a selected hotspot removes
+ * it (and renumbers the rest).
+ */
+import { type ReactNode } from "react";
+import type { InteractionRenderProps } from "../runtime";
+export declare function GraphicOrderReferenceSkin(props: InteractionRenderProps): ReactNode;

package/dist/reference-skin/hotspot.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Reference Skin for `hotspotInteraction` (ADR-0001): SVG hotspot shapes over the
+ * stage image, wired through the option prop-getters (selection semantics identical
+ * to choiceInteraction).
+ */
+import { type ReactNode } from "react";
+import type { InteractionRenderProps } from "../runtime";
+export declare function HotspotReferenceSkin(props: InteractionRenderProps): ReactNode;

package/dist/reference-skin/hottext.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Reference Skin for `hottextInteraction` (ADR-0001): the interaction's flow content is
+ * rendered through the core walk with a `hottext` override, so selectable spans nested
+ * anywhere in the prose become toggle buttons wired through the option prop-getters.
+ */
+import { type ReactNode } from "react";
+import type { InteractionRenderProps } from "../runtime";
+export declare function HottextReferenceSkin(props: InteractionRenderProps): ReactNode;

package/dist/reference-skin/index.d.ts

@@ -0,0 +1,30 @@
+/**
+ * The Reference Skin (ADR-0001): the unstyled, semantic-HTML, a11y-correct Skin set
+ * conform-ed ships so every interaction can be exercised, demoed, and conformance-
+ * tested without a downstream product. Deliberately not a product UI: no styling
+ * beyond data attributes (`data-qti-interaction`, `data-status`) as styling hooks.
+ */
+import type { SkinRegistry } from "../runtime";
+export { textOf } from "./content";
+export { AssociateReferenceSkin } from "./associate";
+export { ChoiceReferenceSkin } from "./choice";
+export { DrawingReferenceSkin } from "./drawing";
+export { EndAttemptReferenceSkin } from "./end-attempt";
+export { ExtendedTextReferenceSkin } from "./extended-text";
+export { GapMatchReferenceSkin } from "./gap-match";
+export { GraphicAssociateReferenceSkin } from "./graphic-associate";
+export { GraphicGapMatchReferenceSkin } from "./graphic-gap-match";
+export { GraphicOrderReferenceSkin } from "./graphic-order";
+export { GraphicStage, shapeCenter, shapeElement } from "./graphic-base";
+export { HotspotReferenceSkin } from "./hotspot";
+export { PositionObjectReferenceSkin } from "./position-object";
+export { SelectPointReferenceSkin } from "./select-point";
+export { HottextReferenceSkin } from "./hottext";
+export { InlineChoiceReferenceSkin } from "./inline-choice";
+export { MatchReferenceSkin } from "./match";
+export { MediaReferenceSkin } from "./media";
+export { OrderReferenceSkin } from "./order";
+export { SliderReferenceSkin } from "./slider";
+export { TextEntryReferenceSkin } from "./text-entry";
+export { UploadReferenceSkin } from "./upload";
+export declare const referenceSkin: SkinRegistry;

package/dist/reference-skin/inline-choice.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Reference Skin for `inlineChoiceInteraction` (ADR-0001): a controlled native select.
+ * Option labels must be text, so choice content goes through plain-text extraction.
+ */
+import { type ReactNode } from "react";
+import type { InteractionRenderProps } from "../runtime";
+export declare function InlineChoiceReferenceSkin(props: InteractionRenderProps): ReactNode;

package/dist/reference-skin/match.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Reference Skin for `matchInteraction` (ADR-0001): a table grid — rows are the first
+ * match set, columns the second; each cell is a checkbox toggling the directedPair
+ * "ROW COL". Conservative and screen-reader friendly; no drag-and-drop.
+ */
+import { type ReactNode } from "react";
+import type { InteractionRenderProps } from "../runtime";
+export declare function MatchReferenceSkin(props: InteractionRenderProps): ReactNode;

package/dist/reference-skin/media.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Reference Skin for `mediaInteraction` (ADR-0001): renders the wrapped audio/video
+ * element itself (skin-owned, so it can count plays), resolving the source through the
+ * runtime's Asset Resolver. The response is the play count as an integer string;
+ * playback is blocked once `maxPlays` is reached.
+ */
+import { type ReactNode } from "react";
+import type { InteractionRenderProps } from "../runtime";
+export declare function MediaReferenceSkin(props: InteractionRenderProps): ReactNode;

package/dist/reference-skin/order.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Reference Skin for `orderInteraction` (ADR-0001): an ordered list with per-item
+ * move-up/move-down buttons — keyboard-accessible reordering without drag-and-drop.
+ * The displayed order is the response; the first move answers with the full order.
+ */
+import { type ReactNode } from "react";
+import type { InteractionRenderProps } from "../runtime";
+export declare function OrderReferenceSkin(props: InteractionRenderProps): ReactNode;

package/dist/reference-skin/position-object.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Reference Skin for `positionObjectStage` (ADR-0001): click the stage to place the
+ * movable object image, centered on the click point. The view models the common
+ * single-interaction stage (one movable object per stage); multi-interaction stages
+ * fail descriptor validation and surface through the capability gate.
+ */
+import { type ReactNode } from "react";
+import type { InteractionRenderProps } from "../runtime";
+export declare function PositionObjectReferenceSkin(props: InteractionRenderProps): ReactNode;

package/dist/reference-skin/select-point.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Reference Skin for `selectPointInteraction` (ADR-0001): click the stage to record a
+ * point (image coordinates). With maxChoices 1 a new click replaces the point;
+ * otherwise clicks append until maxChoices is reached.
+ */
+import { type ReactNode } from "react";
+import type { InteractionRenderProps } from "../runtime";
+export declare function SelectPointReferenceSkin(props: InteractionRenderProps): ReactNode;

package/dist/reference-skin/slider.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Reference Skin for `sliderInteraction` (ADR-0001): a controlled native range input
+ * with a visible current value. Responses are stored as decimal strings; numeric
+ * baseTypes compare numerically in scoring.
+ */
+import { type ReactNode } from "react";
+import type { InteractionRenderProps } from "../runtime";
+export declare function SliderReferenceSkin(props: InteractionRenderProps): ReactNode;

package/dist/reference-skin/text-entry.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Reference Skin for `textEntryInteraction` (ADR-0001): a controlled native text input.
+ */
+import { type ReactNode } from "react";
+import type { InteractionRenderProps } from "../runtime";
+export declare function TextEntryReferenceSkin(props: InteractionRenderProps): ReactNode;

package/dist/reference-skin/upload.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Reference Skin for `uploadInteraction` (ADR-0001): a native file input. The selected
+ * file is stored as a data URL string (QTI `file` base type carries the content); items
+ * using upload are typically scored externally, not by client response processing.
+ */
+import { type ReactNode } from "react";
+import type { InteractionRenderProps } from "../runtime";
+export declare function UploadReferenceSkin(props: InteractionRenderProps): ReactNode;

package/dist/response-processing.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Standard-template scoring helpers, spec-strict by default (ADR-0004). `match_correct`
+ * is an exact match and mapping entries default to caseSensitive=true, per spec. The
+ * optional `normalize` parameter is the Response Normalization hook: a consumer-
+ * configured transform applied to both sides of string comparisons (off by default,
+ * always off in conformance runs). The RP interpreter (`src/rp/`) reuses these for its
+ * `mapResponse` operator; `scoreResponse` also backs the per-interaction feedback
+ * chrome in the runtime. Pure functions: deterministic given (declaration, response),
+ * so scoring is replayable and runs fully offline in the headless core.
+ */
+import type { ResponseNormalization } from "./rp/types";
+import type { ResponseDeclarationView, ResponseValue, ScoreResult } from "./types";
+/**
+ * Lowercase + strip combining diacritics. Exported as a ready-made Response
+ * Normalization for language-learning leniency ("cafe" ≈ "Café") — a documented
+ * deviation a consumer must opt into.
+ */
+export declare function foldString(value: string): string;
+/**
+ * `match_correct`: true when the response exactly matches `correctResponse`, respecting
+ * cardinality and baseType. Spec-strict: no case or diacritic folding unless the
+ * consumer passes a Response Normalization. Returns false when no correctResponse
+ * exists.
+ */
+export declare function matchCorrect(declaration: ResponseDeclarationView, response: ResponseValue, normalize?: ResponseNormalization): boolean;
+/**
+ * `map_response`: sum the mapped values of the response's members, each member mapped at
+ * most once. Per spec, entries default to caseSensitive=true; `caseSensitive: false`
+ * lowercases both sides. A Response Normalization, when configured, applies on top for
+ * string base types. Applies the mapping's `defaultValue` to unmatched members and
+ * clamps to [lowerBound, upperBound]. Returns 0 when no mapping exists.
+ */
+export declare function mapResponse(declaration: ResponseDeclarationView, response: ResponseValue, normalize?: ResponseNormalization): number;
+/**
+ * `map_response_point`: sum the mapped values of the areas hit by the response's point
+ * members. Per spec each area counts at most once regardless of how many points land in
+ * it; points hitting no area add the mapping's `defaultValue`. Clamps to
+ * [lowerBound, upperBound]. Returns 0 when no areaMapping exists.
+ */
+export declare function mapResponsePoint(declaration: ResponseDeclarationView, response: ResponseValue): number;
+/**
+ * Apply the appropriate standard template: `map_response_point` when an areaMapping is
+ * declared, `map_response` when a mapping is declared, otherwise `match_correct`. `maxScore` is the mapping upper bound (or the sum of
+ * positive mapped values) for mapped items, else 1 for match_correct. This heuristic
+ * backs the per-interaction feedback chrome; item outcomes of record come from the RP
+ * interpreter when the item declares `responseProcessing`.
+ */
+export declare function scoreResponse(declaration: ResponseDeclarationView, response: ResponseValue, normalize?: ResponseNormalization): ScoreResult;