@conform-ed/qti-react 0.0.14 → 0.0.16

package/dist/test/results.d.ts

@@ -0,0 +1,102 @@
+/**
+ * QTI Results Reporting — the export builder. Maps a session (test view + resolved
+ * plan + persisted state) onto the AssessmentResult model: one final itemResult per
+ * recorded attempt ("A report may contain multiple results for the same instance of
+ * an item representing multiple attempts … each item result must have a different
+ * datestamp"), pendingResponseProcessing for unflushed simultaneous submissions,
+ * and initial entries for everything else — "all items selected for presentation
+ * should be reported with a corresponding itemResult". The shapes mirror the
+ * contracts result schema structurally; serialization to XML lives in qti-xml.
+ */
+import { type PnpView } from "../pnp";
+import type { OutcomeDeclarationView } from "../rp";
+import type { ResponseDeclarationView, ResponseValue } from "../types";
+import type { AssessmentTestView, TestPlan, TestPlanItem, TestSessionState } from "./types";
+export interface ResultValueView {
+    readonly value: string;
+    /** Required for record-cardinality members, invalid otherwise (schema rule). */
+    readonly fieldIdentifier?: string;
+    readonly baseType?: string;
+}
+export interface ResultResponseVariableView {
+    readonly identifier: string;
+    readonly cardinality: string;
+    readonly baseType?: string;
+    readonly candidateResponse: {
+        readonly values: readonly ResultValueView[];
+    };
+    readonly correctResponse?: {
+        readonly values: readonly ResultValueView[];
+    };
+}
+export interface ResultOutcomeVariableView {
+    readonly identifier: string;
+    readonly cardinality: string;
+    readonly baseType?: string;
+    readonly values: readonly ResultValueView[];
+}
+export type ResultSessionStatus = "final" | "initial" | "pendingExternalScoring" | "pendingResponseProcessing" | "pendingSubmission";
+export interface ItemResultView {
+    readonly identifier: string;
+    readonly sequenceIndex?: number;
+    readonly datestamp: string;
+    readonly sessionStatus: ResultSessionStatus;
+    readonly responseVariables?: readonly ResultResponseVariableView[];
+    readonly outcomeVariables?: readonly ResultOutcomeVariableView[];
+    readonly candidateComment?: string;
+}
+/**
+ * RR Support (§2.6.4): a feature "aligned to the QTI profile of the 1EdTech Access
+ * for All Personal Needs and Preferences (AfA PNP)".
+ */
+export interface ResultSupportView {
+    readonly name: string;
+    readonly assignment: "assigned" | "universal" | "prohibited" | "inherit";
+    readonly value?: string;
+    readonly xmlLang?: string;
+}
+export interface TestResultView {
+    readonly identifier: string;
+    readonly datestamp: string;
+    readonly responseVariables?: readonly ResultResponseVariableView[];
+    readonly outcomeVariables?: readonly ResultOutcomeVariableView[];
+    readonly supports?: readonly ResultSupportView[];
+}
+export interface ResultSessionIdentifierView {
+    readonly sourceId: string;
+    readonly identifier: string;
+}
+export interface ResultContextView {
+    readonly sourcedId?: string;
+    readonly sessionIdentifiers?: readonly ResultSessionIdentifierView[];
+}
+export interface AssessmentResultView {
+    readonly context: ResultContextView;
+    readonly testResult?: TestResultView;
+    readonly itemResults?: readonly ItemResultView[];
+}
+export interface AssessmentResultDocumentView {
+    readonly assessmentResult: AssessmentResultView;
+}
+export interface AssessmentResultItemDetails {
+    readonly responseDeclarations?: readonly ResponseDeclarationView[];
+    readonly outcomeDeclarations?: readonly OutcomeDeclarationView[];
+    /** The clone's resolved correct responses (`AttemptSnapshot.correctResponses`). */
+    readonly correctResponses?: Readonly<Record<string, ResponseValue>>;
+}
+export interface AssessmentResultInput {
+    readonly test: AssessmentTestView;
+    readonly plan: TestPlan;
+    readonly state: TestSessionState;
+    /** Result context (`sourcedId`, session identifiers); the consumer's identifiers. */
+    readonly context?: ResultContextView;
+    /** Export instant for the testResult datestamp (epoch ms; default Date.now()). */
+    readonly nowMs?: number;
+    /** Per-item typing and correct responses; omit (or return null) when unresolvable. */
+    readonly itemDetails?: (item: TestPlanItem) => AssessmentResultItemDetails | null;
+    /** The candidate's AfA PNP the session ran with — reported as testResult supports. */
+    readonly pnp?: PnpView | undefined;
+}
+export declare function buildAssessmentResult(input: AssessmentResultInput): AssessmentResultDocumentView;
+/** Reshape a normalized assessmentResult document into the typed view (import side). */
+export declare function assessmentResultFromNormalized(document: unknown): AssessmentResultView | null;

package/dist/test/session-store.d.ts

@@ -6,9 +6,11 @@
  * processing stays current. React-free — UI layers subscribe like any external store;
  * persistence stays with the consumer (store the seed and `snapshot.state`).
  */
+import type { PnpView } from "../pnp";
 import type { CustomOperatorImplementation, ResponseNormalization } from "../rp";
 import type { AssessmentItemView } from "../runtime";
 import { type AttemptStore } from "../store";
+import type { AssessmentResultDocumentView, ResultContextView } from "./results";
 import type { AssessmentItemRefView, TestController, TestFeedbackView, TestPlanItem, TestSessionState } from "./types";
 export interface TestSessionStoreOptions {
     /**
@@ -23,6 +25,16 @@ export interface TestSessionStoreOptions {
     readonly normalization?: ResponseNormalization;
     /** Registered vendor `customOperator` implementations by class (opt-in). */
     readonly customOperators?: Readonly<Record<string, CustomOperatorImplementation>>;
+    /**
+     * Millisecond clock for the item-session duration clocks (pair it with the
+     * controller's `now` for coherent timing). Defaults to Date.now.
+     */
+    readonly now?: () => number;
+    /**
+     * The candidate's AfA PNP — pair it with the controller's `pnp` (time-limit
+     * accommodations live there). The store reports it as result supports.
+     */
+    readonly pnp?: PnpView;
 }
 export interface TestSessionSnapshot {
     readonly state: TestSessionState;
@@ -42,5 +54,25 @@ export interface TestSessionStore {
     readonly canMoveTo: (itemKey: string) => boolean;
     readonly moveTo: (itemKey: string) => void;
     readonly end: () => void;
+    /** Fold elapsed time and apply time-limit expiries; consumers drive the cadence. */
+    readonly tick: () => void;
+    /** Post-end review navigation (allowReview); a no-op where review is barred. */
+    readonly review: (itemKey: string) => void;
+    /** Record a candidate comment (allowComment); a no-op where comments are barred. */
+    readonly setItemComment: (itemKey: string, comment: string) => void;
+    /** Suspend the session: every scope clock and the current item's clock stop. */
+    readonly suspend: () => void;
+    /** Resume a suspended session; the gap never accrues to any duration. */
+    readonly resume: () => void;
+    /**
+     * Build the QTI Results Reporting document for the session as it stands:
+     * per-attempt final itemResults, pending submissions, initial entries for
+     * everything else, typed by the resolved item views and the clones' correct
+     * responses. Serialize with qti-xml's `serializeQtiAssessmentResult`.
+     */
+    readonly assessmentResult: (options?: {
+        readonly context?: ResultContextView;
+        readonly nowMs?: number;
+    }) => AssessmentResultDocumentView;
 }
 export declare function createTestSessionStore(controller: TestController, options: TestSessionStoreOptions): TestSessionStore;

package/dist/test/types.d.ts

@@ -7,6 +7,7 @@
 import type { CapabilityIssue } from "../capability";
 import type { OutcomeDeclarationView, OutcomeValue, RpExpressionView } from "../rp";
 import type { BodyNode } from "../runtime";
+import type { ResponseValue } from "../types";
 export interface BranchRuleView {
     /** A target identifier in the same test part, or EXIT_TEST / EXIT_TESTPART / EXIT_SECTION. */
     readonly target: string;
@@ -29,14 +30,25 @@ export interface ItemSessionControlView {
     readonly validateResponses?: boolean;
 }
 /**
- * QTI `timeLimits` (seconds). The controller is clock-free by design (ADR-0005): these
- * are data for the consumer's timers, which call `next()`/`end()` when time runs out.
+ * QTI `timeLimits` (seconds). The controller enforces these under an injectable clock
+ * (`TestControllerOptions.now`): expiry checks fold elapsed time at every transition,
+ * and consumers drive their own timers by calling `tick()` (ADR-0005, "Timing and
+ * time limits"). The values still surface on the plan for consumer-side countdowns.
  */
 export interface TimeLimitsView {
     readonly minTime?: number;
     readonly maxTime?: number;
     readonly allowLateSubmission?: boolean;
 }
+/**
+ * "The default value of a template variable in an item can be overridden based on
+ * the test context in which the template is instantiated." (§5.152) The expression
+ * evaluates at test level (it may read other items' variables and test outcomes).
+ */
+export interface TemplateDefaultView {
+    readonly templateIdentifier: string;
+    readonly expression: RpExpressionView;
+}
 export interface AssessmentItemRefView {
     readonly kind: "assessmentItemRef";
     readonly identifier: string;
@@ -53,6 +65,7 @@ export interface AssessmentItemRefView {
         readonly identifier: string;
         readonly value: number;
     }>;
+    readonly templateDefaults?: readonly TemplateDefaultView[];
 }
 export interface AssessmentSectionView {
     readonly kind: "assessmentSection";
@@ -61,6 +74,12 @@ export interface AssessmentSectionView {
     readonly visible?: boolean;
     readonly fixed?: boolean;
     readonly required?: boolean;
+    /**
+     * For an invisible section under a shuffling parent: whether its children are
+     * "shuffled as a block or mixed up with the other children of the parent section"
+     * (§4.2.7). Default true (block).
+     */
+    readonly keepTogether?: boolean;
     readonly selection?: {
         readonly select: number;
         readonly withReplacement?: boolean;
@@ -95,11 +114,16 @@ export interface OutcomeConditionBranch {
     readonly expression: RpExpressionView;
     readonly rules: readonly OutcomeRuleView[];
 }
-/** One outcome rule: outcomeCondition, setOutcomeValue, or exitTest. */
+/**
+ * One outcome rule: outcomeCondition, setOutcomeValue, lookupOutcomeValue,
+ * outcomeProcessingFragment, or exitTest.
+ */
 export interface OutcomeRuleView {
     readonly kind: string;
     readonly identifier?: string;
     readonly expression?: RpExpressionView;
+    /** Nested rules of an `outcomeProcessingFragment` (§5.103). */
+    readonly rules?: readonly OutcomeRuleView[];
     readonly outcomeIf?: OutcomeConditionBranch;
     readonly outcomeElseIfs?: readonly OutcomeConditionBranch[];
     readonly outcomeElse?: {
@@ -118,8 +142,17 @@ export interface AssessmentTestView {
     readonly testFeedbacks?: readonly TestFeedbackView[];
 }
 export interface TestPlanItem {
-    /** The item ref identifier — unique within the test, used as the session key. */
+    /**
+     * The session key: the ref identifier, or `identifier.n` when selection
+     * with-replacement instantiates the ref more than once — the spec's own instance
+     * addressing, where "a number that denotes the instance's place in the sequence of
+     * the item's instantiation is inserted between the item variable identifier and
+     * the item variable" (§2.11.1.2). Identifiers cannot contain periods, so the two
+     * forms never collide.
+     */
     readonly key: string;
+    /** 1-based instantiation number; present only when the ref has multiple instances. */
+    readonly instance?: number;
     readonly ref: AssessmentItemRefView;
     readonly partIdentifier: string;
     readonly sectionPath: readonly string[];
@@ -137,9 +170,16 @@ export interface TestPlanPart {
     readonly timeLimits?: TimeLimitsView;
     readonly items: readonly TestPlanItem[];
 }
+/** A section that survived selection, keyed for duration tracking and time limits. */
+export interface TestPlanSection {
+    readonly identifier: string;
+    readonly timeLimits?: TimeLimitsView;
+}
 export interface TestPlan {
     readonly timeLimits?: TimeLimitsView;
     readonly parts: readonly TestPlanPart[];
+    /** Every planned section by identifier (spec-unique across parts/sections/refs). */
+    readonly sections: Readonly<Record<string, TestPlanSection>>;
 }
 export interface TestItemResult {
     readonly outcomes: Readonly<Record<string, OutcomeValue>>;
@@ -152,9 +192,90 @@ export interface TestItemResult {
     readonly responded?: boolean;
     /** Adaptive items manage their own attempt lifecycle, so maxAttempts is ignored (spec). */
     readonly adaptive?: boolean;
+    /**
+     * The item session's elapsed seconds (`AttemptSnapshot.durationSeconds`). Resolves
+     * the built-in `ITEM.duration` in outcome processing; unreported → NULL.
+     */
+    readonly durationSeconds?: number;
+    /**
+     * Whether the responses satisfy the interaction constraints (response-validity).
+     * Under effective `validateResponses` in an individual-submission part, `false`
+     * makes the controller refuse the submission ("candidates are not allowed to
+     * submit the item until they have provided valid responses for all interactions").
+     */
+    readonly valid?: boolean;
+    /**
+     * The candidate's responses as submitted — recorded into the attempt history so
+     * results reporting can emit `candidateResponse` values from persisted state.
+     */
+    readonly responses?: Readonly<Record<string, ResponseValue>>;
+    /**
+     * The submission instant (epoch ms). Controller-stamped: callers never set it;
+     * it rides pending simultaneous results so the flush keeps submit-time stamps.
+     */
+    readonly submittedAtMs?: number;
+}
+/**
+ * One committed attempt, recorded for results reporting: "A report may contain
+ * multiple results for the same instance of an item representing multiple attempts
+ * … each item result must have a different datestamp."
+ */
+export interface RecordedAttempt {
+    /** Submission instant (epoch ms) — the itemResult datestamp. */
+    readonly atMs: number;
+    readonly outcomes: Readonly<Record<string, OutcomeValue>>;
+    readonly responses?: Readonly<Record<string, ResponseValue>>;
+    /** The item session's elapsed seconds at this submission, when reported. */
+    readonly durationSeconds?: number;
+}
+/**
+ * Wall-clock accounting folded at every controller transition (and `tick()`).
+ * Durations are always "as of" `lastTransitionAtMs` — scoring and enforcement read
+ * recorded state only (ADR-0004 determinism). Until a suspend/resume API exists,
+ * these include all wall time between transitions.
+ */
+export interface TestTimingState {
+    /** Injected-clock milliseconds at the last fold. */
+    readonly lastTransitionAtMs: number;
+    /** Whole-test seconds (the bare `duration` built-in, §2.8.5). */
+    readonly testSeconds: number;
+    /** Seconds per test-part identifier (`P1.duration`). */
+    readonly partSeconds: Readonly<Record<string, number>>;
+    /** Seconds per section identifier — a leaf accrues to every ancestor (`S2.duration`). */
+    readonly sectionSeconds: Readonly<Record<string, number>>;
+    /**
+     * Seconds each item has been the current item — the enforcement clock for item
+     * minTime/maxTime. The `ITEM.duration` variable reads the consumer report instead.
+     */
+    readonly itemSeconds: Readonly<Record<string, number>>;
+}
+export type TimingScopeRef = {
+    readonly kind: "test";
+} | {
+    readonly kind: "part";
+    readonly identifier: string;
+} | {
+    readonly kind: "section";
+    readonly identifier: string;
+} | {
+    readonly kind: "item";
+    readonly key: string;
+};
+/** A late submission the controller refused (ADR-0003: no silent drops). */
+export interface RejectedSubmission {
+    readonly itemKey: string;
+    /** The innermost exceeded scope whose allowLateSubmission did not permit it. */
+    readonly scope: TimingScopeRef;
+    /** Test-scope seconds at rejection (audit stamp on the session clock). */
+    readonly atTestSeconds: number;
 }
 export interface TestSessionState {
-    readonly status: "in-progress" | "ended";
+    /**
+     * `suspended` stops every scope clock and blocks transitions until `resume()` —
+     * the gap never accrues to any duration ("minus any time the session was in the
+     * suspended state"). Pre-suspension persisted states only ever carry the other two.
+     */
+    readonly status: "in-progress" | "suspended" | "ended";
     readonly currentItemKey: string | null;
     readonly itemOutcomes: Readonly<Record<string, Readonly<Record<string, OutcomeValue>>>>;
     readonly attemptedItems: readonly string[];
@@ -173,8 +294,28 @@ export interface TestSessionState {
      */
     readonly pendingItemResults: Readonly<Record<string, TestItemResult>>;
     readonly testOutcomes: Readonly<Record<string, OutcomeValue>>;
+    /** Timing accumulators; absent on pre-timing persisted states (initialized lazily). */
+    readonly timing?: TestTimingState;
+    /**
+     * Evaluated `templateDefault` values per item key, recorded at the spec's times
+     * (§5.152: linear — when the item first becomes current; nonlinear — at testPart
+     * start) so item-store creation reads a stable, replayable value.
+     */
+    readonly templateDefaultValues?: Readonly<Record<string, Readonly<Record<string, OutcomeValue>>>>;
+    /** Latest consumer-reported item-session duration per item key (feeds `ITEM.duration`). */
+    readonly itemDurationSeconds?: Readonly<Record<string, number>>;
+    readonly rejectedSubmissions?: readonly RejectedSubmission[];
+    /**
+     * Candidate comments per item key (allowComment): "feedback from the candidate to
+     * the other actors in the assessment process", never part of the assessed responses.
+     */
+    readonly itemComments?: Readonly<Record<string, string>>;
+    /** Committed attempts per item key, in submission order (results reporting). */
+    readonly attemptHistory?: Readonly<Record<string, readonly RecordedAttempt[]>>;
 }
 export interface TestController {
+    /** The assessment test view this controller was created from. */
+    readonly test: AssessmentTestView;
     readonly plan: TestPlan;
     /** Static capability issues found in outcome processing, preconditions, and branch rules. */
     readonly issues: readonly CapabilityIssue[];
@@ -190,5 +331,32 @@ export interface TestController {
     readonly canSubmitItem: (state: TestSessionState, itemKey: string) => boolean;
     readonly submitItem: (state: TestSessionState, itemKey: string, result: TestItemResult) => TestSessionState;
     readonly end: (state: TestSessionState) => TestSessionState;
+    /**
+     * Fold elapsed time into the recorded durations and apply any max-time expiries
+     * (forced moves / forced end). Consumers run their own timers and call this;
+     * identity once the session has ended (the clock stops at end).
+     */
+    readonly tick: (state: TestSessionState) => TestSessionState;
     readonly visibleTestFeedbacks: (state: TestSessionState) => readonly TestFeedbackView[];
+    /**
+     * Post-end review (allowReview): whether the candidate may re-enter the item
+     * read-only — the session has ended, the item was presented, and its effective
+     * allowReview permits it.
+     */
+    readonly canReview: (state: TestSessionState, itemKey: string) => boolean;
+    /** Navigate review: sets the current item without reopening the ended session. */
+    readonly review: (state: TestSessionState, itemKey: string) => TestSessionState;
+    /** Whether a comment may be recorded: effective allowComment, session in progress. */
+    readonly canComment: (state: TestSessionState, itemKey: string) => boolean;
+    readonly setItemComment: (state: TestSessionState, itemKey: string, comment: string) => TestSessionState;
+    /**
+     * Suspend the session: folds the clock up to this instant (applying any expiry
+     * that fold reveals), then stops it. Identity unless in progress.
+     */
+    readonly suspend: (state: TestSessionState) => TestSessionState;
+    /**
+     * Resume a suspended session: re-stamps the clock at the current instant without
+     * folding the gap — suspended time never accrues. Identity unless suspended.
+     */
+    readonly resume: (state: TestSessionState) => TestSessionState;
 }

package/dist/types.d.ts

@@ -45,6 +45,11 @@ export interface ResponseDeclarationView {
     readonly identifier: string;
     readonly cardinality: Cardinality;
     readonly baseType?: string;
+    readonly defaultValue?: {
+        readonly values: ReadonlyArray<{
+            readonly value: string | number | boolean;
+        }>;
+    };
     readonly correctResponse?: CorrectResponseView;
     readonly mapping?: MappingView;
     readonly areaMapping?: AreaMappingView;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@conform-ed/qti-react",
-  "version": "0.0.14",
+  "version": "0.0.16",
   "files": [
     "src",
     "dist"
@@ -20,7 +20,11 @@
     "test": "bun test",
     "typecheck": "tsgo --noEmit"
   },
+  "dependencies": {
+    "xspattern": "^3.1.0"
+  },
   "devDependencies": {
+    "@conform-ed/contracts": "0.0.16",
     "@conform-ed/qti-xml": "0.0.13",
     "@types/react": "^19.2.17",
     "@types/react-dom": "^19",

package/src/content-model.ts

@@ -39,7 +39,11 @@ export const v0InteractionKinds = [
 
 export type V0InteractionKind = (typeof v0InteractionKinds)[number];
 
-/** Allowed HTML flow/inline element names for generic `kind: "xml"` body nodes. */
+/**
+ * Allowed HTML flow/inline element names for generic `kind: "xml"` body nodes — the
+ * complete QTI HTML vocabulary as the official ASI XSD enumerates it
+ * (HTMLContentDType), not all of HTML5.
+ */
 const v0FlowElements = new Set<string>([
   "p",
   "span",
@@ -53,11 +57,14 @@ const v0FlowElements = new Set<string>([
   "ul",
   "ol",
   "li",
-  // language-critical
+  // language-critical (§2.14: ruby/furigana, bidirectional text)
   "ruby",
   "rb",
   "rt",
   "rp",
+  "rtc",
+  "bdo",
+  "bdi",
   // media (the first media-milestone growth; src/poster route through the Asset Resolver)
   "img",
   "audio",
@@ -89,10 +96,38 @@ const v0FlowElements = new Set<string>([
   "tr",
   "th",
   "td",
+  // the rest of the XSD's enumerated vocabulary
+  "a",
+  "abbr",
+  "acronym",
+  "address",
+  "article",
+  "aside",
+  "big",
+  "code",
+  "details",
+  "summary",
+  "dfn",
+  "dl",
+  "dt",
+  "dd",
+  "kbd",
+  "label",
+  "nav",
+  "pre",
+  "q",
+  "samp",
+  "small",
+  "tt",
+  "var",
+  "footer",
+  "header",
 ]);
 
 /** Element-specific attribute allowlists, additive to the global set. */
 const v0ElementAttributes: ReadonlyMap<string, ReadonlySet<string>> = new Map([
+  // The XSD's attribute schematron for anchors: href and type beyond the global set.
+  ["a", new Set(["href", "type"])],
   ["img", new Set(["src", "alt", "width", "height"])],
   ["audio", new Set(["src", "controls", "loop", "muted", "preload"])],
   ["video", new Set(["src", "controls", "loop", "muted", "preload", "poster", "width", "height"])],
@@ -102,7 +137,7 @@ const v0ElementAttributes: ReadonlyMap<string, ReadonlySet<string>> = new Map([
 ]);
 
 /** Attribute names treated as packaged-asset references (rewritten by the Asset Resolver). */
-const v0UrlAttributes = new Set<string>(["src", "poster", "data"]);
+const v0UrlAttributes = new Set<string>(["src", "poster", "data", "href"]);
 
 /**
  * The MathML root. Its subtree is rendered structurally (presentation MathML) with the
@@ -180,7 +215,12 @@ export function sanitizeAttributes(
       continue;
     }
 
-    if (!model.globalAttributes.has(name) && !elementAllowed?.has(name)) {
+    // WAI-ARIA characteristics (§2.13.3) and data-* extension attributes are part of
+    // the QTI vocabulary (the XSD's own attribute schematron) and have no scripting
+    // surface; everything else must be allowlisted.
+    const ariaOrData = name === "role" || name.startsWith("aria-") || name.startsWith("data-");
+
+    if (!ariaOrData && !model.globalAttributes.has(name) && !elementAllowed?.has(name)) {
       continue;
     }
 

package/src/index.ts

@@ -14,7 +14,11 @@ export {
 
 export { foldString, mapResponse, matchCorrect, mapResponsePoint, scoreResponse } from "./response-processing";
 
-export { assessmentItemViewFromNormalized, assessmentTestViewFromNormalized } from "./normalized-item";
+export {
+  assessmentItemViewFromNormalized,
+  assessmentTestViewFromNormalized,
+  stimulusContentFromNormalized,
+} from "./normalized-item";
 
 export { formatPoint, parseCoords, parsePoint, pointInShape, type Point, type QtiShape } from "./graphic";
 
@@ -30,6 +34,10 @@ export {
 
 export type {
   CustomOperatorImplementation,
+  InterpolationTableEntryView,
+  InterpolationTableView,
+  MatchTableEntryView,
+  MatchTableView,
   MaybeRpValue,
   OutcomeDeclarationView,
   OutcomeValue,
@@ -53,6 +61,14 @@ export type {
 
 export { createAttemptStore, type AttemptSnapshot, type AttemptStore, type AttemptStoreOptions } from "./store";
 
+export {
+  collectInteractionConstraints,
+  collectResponseViolations,
+  type InteractionConstraint,
+  type ResponseConstraintKind,
+  type ResponseViolation,
+} from "./response-validity";
+
 export {
   createTestController,
   createTestSessionStore,
@@ -69,18 +85,24 @@ export {
   type TestController,
   type TestFeedbackView,
   type TestItemResult,
+  type RejectedSubmission,
+  type TemplateDefaultView,
   type TestPartView,
   type TestPlan,
   type TestPlanItem,
   type TestPlanPart,
+  type TestPlanSection,
   type TestSessionState,
+  type TestTimingState,
   type TimeLimitsView,
+  type TimingScopeRef,
 } from "./test";
 
 export {
   createQtiRuntime,
   defineInteraction,
   type AssessmentItemView,
+  type AssessmentStimulusRefView,
   type AttemptController,
   type BodyNode,
   type CapabilityIssue,
@@ -94,12 +116,14 @@ export {
   type InteractionSkin,
   type InteractionStatus,
   type ItemRendererProps,
+  type ItemRenderMode,
   type NodeOverrides,
   type OptionProps,
   type OptionStatus,
   type QtiRuntime,
   type QtiRuntimeConfig,
   type SkinRegistry,
+  type StimulusContentView,
   type XmlContentNode,
 } from "./runtime";
 
@@ -183,3 +207,21 @@ export type {
   ResponseValue,
   ScoreResult,
 } from "./types";
+
+export {
+  resolveCatalogSupports,
+  resolvePnpActivation,
+  type CatalogCardEntryView,
+  type CatalogCardView,
+  type CatalogContentView,
+  type CatalogFileHrefView,
+  type CatalogResolution,
+  type CatalogView,
+  type PnpActivation,
+  type PnpAdditionalTestingTimeView,
+  type PnpFeatureSetView,
+  type PnpLanguageModeView,
+  type PnpReplaceAccessModeView,
+  type PnpView,
+  type ResolvedCatalogSupport,
+} from "./pnp";