@conform-ed/qti-react 0.0.13 → 0.0.15

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;

package/dist/rp/evaluate.d.ts

@@ -0,0 +1,35 @@
+/**
+ * The shared QTI expression evaluator (ADR-0004), used by both response processing and
+ * template processing. The environment supplies variable lookup, declarations, and —
+ * only where the spec allows nondeterminism (template processing) — a seeded PRNG.
+ * Random operators without a PRNG in the environment are unsupported constructs:
+ * response processing must stay deterministic and replayable.
+ */
+import type { ResponseDeclarationView, ResponseValue } from "../types";
+import type { CustomOperatorImplementation, ResponseNormalization, RpExpressionView } from "./types";
+import { type MaybeRpValue } from "./values";
+export interface EvalEnv {
+    readonly lookupVariable: (identifier: string) => MaybeRpValue;
+    readonly responseDeclaration: (identifier: string) => ResponseDeclarationView | undefined;
+    readonly responseValue: (identifier: string) => ResponseValue;
+    readonly normalization?: ResponseNormalization | undefined;
+    /** Seeded PRNG in [0, 1); present only in template processing. */
+    readonly random?: (() => number) | undefined;
+    /** `testVariables` aggregation; present only in test-level outcome processing. */
+    readonly testVariables?: (expression: RpExpressionView) => MaybeRpValue;
+    /** The `number*` item-session aggregates; present only in test-level outcome processing. */
+    readonly testAggregate?: (expression: RpExpressionView) => MaybeRpValue;
+    /** Registered vendor operators by class; unregistered classes stay unsupported. */
+    readonly customOperators?: Readonly<Record<string, CustomOperatorImplementation>> | undefined;
+}
+/** Expression kinds legal everywhere (deterministic). */
+export declare const deterministicExpressionKinds: ReadonlySet<string>;
+/** Expression kinds requiring the seeded PRNG (template processing only). */
+export declare const randomExpressionKinds: ReadonlySet<string>;
+export declare class RpUnsupportedError extends Error {
+    readonly kindName: string;
+    constructor(kindName: string);
+}
+export declare function evaluateExpression(expression: RpExpressionView, env: EvalEnv): MaybeRpValue;
+/** Walk an expression tree, reporting kinds outside the allowed set. */
+export declare function collectExpressionIssues(expression: RpExpressionView, allowedKinds: ReadonlySet<string>, report: (name: string) => void, customOperatorClasses?: ReadonlySet<string>): void;

package/dist/rp/index.d.ts

@@ -0,0 +1,4 @@
+export { collectRpIssues, executeResponseProcessing } from "./interpreter";
+export { applyCorrectResponseOverrides, collectTemplateIssues, executeTemplateProcessing, mulberry32, type TemplateConditionBranch, type TemplateProcessingContext, type TemplateProcessingResult, type TemplateProcessingView, type TemplateRuleView, } from "./template-processing";
+export { resolveTemplate } from "./templates";
+export type { CustomOperatorImplementation, MaybeRpValue, OutcomeDeclarationView, OutcomeValue, ResponseNormalization, ResponseProcessingContext, ResponseProcessingResult, ResponseProcessingView, RpConditionBranch, RpExpressionView, RpRecordField, RpRuleView, RpScalar, RpValue, TemplateDeclarationView, } from "./types";

package/dist/rp/interpreter.d.ts

@@ -0,0 +1,15 @@
+/**
+ * The Response Processing Interpreter (ADR-0004): a pure, deterministic evaluator of
+ * the contracts-validated `responseProcessing` tree. Operator coverage grows milestone
+ * by milestone; anything outside it aborts execution to the declared outcome defaults
+ * and is reported as an `unsupported-rp` Capability issue — never partial scoring.
+ */
+import type { CapabilityIssue } from "../capability";
+import type { ResponseProcessingContext, ResponseProcessingResult, ResponseProcessingView } from "./types";
+export declare function executeResponseProcessing(view: ResponseProcessingView | undefined, context: ResponseProcessingContext): ResponseProcessingResult;
+export interface RpIssueOptions {
+    /** `customOperator` classes the consumer has registered implementations for. */
+    readonly customOperatorClasses?: ReadonlySet<string>;
+}
+/** Static coverage walk for `canDeliver`: reports constructs the interpreter lacks without executing. */
+export declare function collectRpIssues(view: ResponseProcessingView | undefined, options?: RpIssueOptions): readonly CapabilityIssue[];

package/dist/rp/template-processing.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Template processing (ADR-0004): the seeded, deterministic engine that produces an
+ * item clone. Given the same seed, the same template values and correctResponse
+ * overrides come out — replayability survives randomized items because the seed, not
+ * the outcome, is what gets stored. Supported rules: setTemplateValue,
+ * templateCondition, setCorrectResponse, exitTemplate.
+ */
+import type { CapabilityIssue } from "../capability";
+import type { CorrectResponseView, ResponseDeclarationView } from "../types";
+import type { CustomOperatorImplementation, OutcomeValue, RpExpressionView, TemplateDeclarationView } from "./types";
+export interface TemplateConditionBranch {
+    readonly expression: RpExpressionView;
+    readonly rules: readonly TemplateRuleView[];
+}
+export interface TemplateRuleView {
+    readonly kind: string;
+    readonly identifier?: string;
+    readonly expression?: RpExpressionView;
+    readonly templateIf?: TemplateConditionBranch;
+    readonly templateElseIfs?: readonly TemplateConditionBranch[];
+    readonly templateElse?: {
+        readonly rules: readonly TemplateRuleView[];
+    };
+}
+export interface TemplateProcessingView {
+    readonly rules: readonly TemplateRuleView[];
+}
+export interface TemplateProcessingContext {
+    readonly templateDeclarations: readonly TemplateDeclarationView[];
+    readonly responseDeclarations: readonly ResponseDeclarationView[];
+    readonly seed: number;
+    /** Registered vendor `customOperator` implementations by class (opt-in). */
+    readonly customOperators?: Readonly<Record<string, CustomOperatorImplementation>> | undefined;
+}
+export interface TemplateProcessingResult {
+    readonly templateValues: Readonly<Record<string, OutcomeValue>>;
+    /** correctResponse values set by setCorrectResponse, keyed by response identifier. */
+    readonly correctResponseOverrides: Readonly<Record<string, CorrectResponseView>>;
+    readonly issues: readonly CapabilityIssue[];
+}
+/** mulberry32: a tiny, fast, seeded PRNG — deterministic across platforms. */
+export declare function mulberry32(seed: number): () => number;
+export declare function executeTemplateProcessing(view: TemplateProcessingView | undefined, context: TemplateProcessingContext): TemplateProcessingResult;
+/** The effective response declarations for a clone: setCorrectResponse overrides applied. */
+export declare function applyCorrectResponseOverrides(declarations: readonly ResponseDeclarationView[], overrides: Readonly<Record<string, CorrectResponseView>>): readonly ResponseDeclarationView[];
+/** Static coverage walk for `canDeliver` over a templateProcessing tree. */
+export declare function collectTemplateIssues(view: TemplateProcessingView | undefined, options?: {
+    readonly customOperatorClasses?: ReadonlySet<string>;
+}): readonly CapabilityIssue[];