@conform-ed/qti-react 0.0.18 → 0.0.20

package/dist/index.d.ts

@@ -1,6 +1,7 @@
 export declare const qtiReactPackageName = "@conform-ed/qti-react";
 export { v0ContentModel, v0InteractionKinds, isAllowedFlowElement, isInteractionKind, sanitizeAttributes, type ContentModel, type V0InteractionKind, } from "./content-model";
 export { foldString, mapResponse, matchCorrect, mapResponsePoint, scoreResponse } from "./response-processing";
+export { effectiveItemScore, type EffectiveItemScore } from "./item-score";
 export { assessmentItemViewFromNormalized, assessmentTestViewFromNormalized, stimulusContentFromNormalized, } from "./normalized-item";
 export { referenceInteractionKinds, reportItemCapability, type ItemCapabilityOptions } from "./item-capability";
 export { formatPoint, parseCoords, parsePoint, pointInShape, type Point, type QtiShape } from "./graphic";
@@ -15,3 +16,5 @@ export { associateInteraction, choiceInteraction, drawingInteraction, endAttempt
 export { AssociateReferenceSkin, ChoiceReferenceSkin, DrawingReferenceSkin, EndAttemptReferenceSkin, ExtendedTextReferenceSkin, GapMatchReferenceSkin, GraphicAssociateReferenceSkin, GraphicGapMatchReferenceSkin, GraphicOrderReferenceSkin, GraphicStage, HotspotReferenceSkin, HottextReferenceSkin, InlineChoiceReferenceSkin, MatchReferenceSkin, MediaReferenceSkin, OrderReferenceSkin, PositionObjectReferenceSkin, SelectPointReferenceSkin, SliderReferenceSkin, TextEntryReferenceSkin, UploadReferenceSkin, referenceSkin, textOf, } from "./reference-skin";
 export type { AreaMapEntryView, AreaMappingView, Cardinality, CorrectResponseView, MapEntryView, MappingView, ResponseDeclarationView, 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";
+export { cardinalitySchema, interpolationTableSchema, matchTableSchema, outcomeDeclarationSchema, rpExpressionSchema, rpScalarSchema, type OutcomeDeclarationSchema, type RpExpressionSchema, type RpScalarSchema, } from "./rp/schema";
+export { assessmentItemRefViewSchema, assessmentTestViewSchema, branchRuleSchema, itemSessionControlSchema, makeAssessmentTestSchema, orderingSchema, outcomeConditionBranchSchema, outcomeProcessingSchema, outcomeRuleSchema, selectionSchema, testFeedbackSchema, timeLimitsSchema, type AssessmentItemRefViewSchema, type AssessmentSectionNode, type AssessmentTestNode, type AssessmentTestSchemas, type AssessmentTestViewSchema, type BranchRuleSchema, type ItemSessionControlSchema, type OrderingSchema, type SelectionSchema, type TestPartNode, type TimeLimitsSchema, } from "./test/schema";

package/dist/index.js

@@ -387,6 +387,23 @@ function scoreResponse(declaration, response, normalize) {
     correct
   };
 }
+// src/item-score.ts
+function numericOutcome(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
+function effectiveItemScore(scores, outcomes) {
+  const scoreOutcome = numericOutcome(outcomes["SCORE"]);
+  const maxOutcome = numericOutcome(outcomes["MAXSCORE"]);
+  const summedMax = scores.reduce((total, score) => total + score.maxScore, 0);
+  if (scoreOutcome !== null) {
+    return { raw: scoreOutcome, max: maxOutcome ?? summedMax, fromOutcomes: true };
+  }
+  return {
+    raw: scores.reduce((total, score) => total + score.score, 0),
+    max: maxOutcome ?? summedMax,
+    fromOutcomes: false
+  };
+}
 // src/normalized-item.ts
 function isRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -6783,6 +6800,177 @@ var referenceSkin = {
   textEntryInteraction: TextEntryReferenceSkin,
   uploadInteraction: UploadReferenceSkin
 };
+// src/rp/schema.ts
+import { z as z18 } from "zod";
+var rpScalarSchema = z18.union([z18.string(), z18.number(), z18.boolean()]);
+var numberOrRef = z18.union([z18.number(), z18.string()]);
+var categoryFilter = z18.union([z18.string(), z18.array(z18.string())]);
+var cardinalitySchema = z18.enum(["single", "multiple", "ordered", "record"]);
+var rpExpressionSchema = z18.lazy(() => z18.object({
+  kind: z18.string(),
+  identifier: z18.string().optional(),
+  baseType: z18.string().optional(),
+  value: rpScalarSchema.optional(),
+  expressions: z18.array(rpExpressionSchema).optional(),
+  min: numberOrRef.optional(),
+  max: numberOrRef.optional(),
+  step: numberOrRef.optional(),
+  toleranceMode: z18.enum(["exact", "absolute", "relative"]).optional(),
+  tolerance: z18.array(numberOrRef).optional(),
+  includeLowerBound: z18.boolean().optional(),
+  includeUpperBound: z18.boolean().optional(),
+  n: numberOrRef.optional(),
+  name: z18.string().optional(),
+  roundingMode: z18.enum(["decimalPlaces", "significantFigures"]).optional(),
+  figures: numberOrRef.optional(),
+  numberRepeats: numberOrRef.optional(),
+  pattern: z18.string().optional(),
+  caseSensitive: z18.boolean().optional(),
+  substring: z18.boolean().optional(),
+  shape: z18.string().optional(),
+  coords: z18.string().optional(),
+  variableIdentifier: z18.string().optional(),
+  outcomeIdentifier: z18.string().optional(),
+  weightIdentifier: z18.string().optional(),
+  sectionIdentifier: z18.string().optional(),
+  includeCategory: categoryFilter.optional(),
+  excludeCategory: categoryFilter.optional(),
+  class: z18.string().optional(),
+  definition: z18.string().optional(),
+  fieldIdentifier: z18.string().optional()
+}));
+var matchTableSchema = z18.object({
+  defaultValue: rpScalarSchema.optional(),
+  matchTableEntries: z18.array(z18.object({ sourceValue: z18.number(), targetValue: rpScalarSchema }))
+});
+var interpolationTableSchema = z18.object({
+  defaultValue: rpScalarSchema.optional(),
+  interpolationTableEntries: z18.array(z18.object({
+    sourceValue: z18.number(),
+    targetValue: rpScalarSchema,
+    includeBoundary: z18.boolean().optional()
+  }))
+});
+var outcomeDeclarationSchema = z18.object({
+  identifier: z18.string(),
+  cardinality: cardinalitySchema,
+  baseType: z18.string().optional(),
+  defaultValue: z18.object({ values: z18.array(z18.object({ value: rpScalarSchema })) }).optional(),
+  matchTable: matchTableSchema.optional(),
+  interpolationTable: interpolationTableSchema.optional(),
+  normalMaximum: z18.number().optional(),
+  normalMinimum: z18.number().optional()
+});
+// src/test/schema.ts
+import { z as z19 } from "zod";
+var timeLimitsSchema = z19.object({
+  minTime: z19.number().nonnegative().optional(),
+  maxTime: z19.number().nonnegative().optional(),
+  allowLateSubmission: z19.boolean().optional()
+});
+var itemSessionControlSchema = z19.object({
+  maxAttempts: z19.number().int().nonnegative().optional(),
+  showFeedback: z19.boolean().optional(),
+  allowReview: z19.boolean().optional(),
+  showSolution: z19.boolean().optional(),
+  allowComment: z19.boolean().optional(),
+  allowSkipping: z19.boolean().optional(),
+  validateResponses: z19.boolean().optional()
+});
+var selectionSchema = z19.object({
+  select: z19.number().int().nonnegative(),
+  withReplacement: z19.boolean().optional()
+});
+var orderingSchema = z19.object({ shuffle: z19.boolean().optional() });
+var branchRuleSchema = z19.object({
+  target: z19.string().trim().min(1),
+  expression: rpExpressionSchema
+});
+var weightSchema = z19.object({ identifier: z19.string().trim().min(1), value: z19.number() });
+var templateDefaultSchema = z19.object({
+  templateIdentifier: z19.string().trim().min(1),
+  expression: rpExpressionSchema
+});
+var outcomeConditionBranchSchema = z19.lazy(() => z19.object({
+  expression: rpExpressionSchema,
+  rules: z19.array(outcomeRuleSchema)
+}));
+var outcomeRuleSchema = z19.lazy(() => z19.object({
+  kind: z19.string(),
+  identifier: z19.string().optional(),
+  expression: rpExpressionSchema.optional(),
+  rules: z19.array(outcomeRuleSchema).optional(),
+  outcomeIf: outcomeConditionBranchSchema.optional(),
+  outcomeElseIfs: z19.array(outcomeConditionBranchSchema).optional(),
+  outcomeElse: z19.object({ rules: z19.array(outcomeRuleSchema) }).optional()
+}));
+var outcomeProcessingSchema = z19.object({ rules: z19.array(outcomeRuleSchema) });
+var testFeedbackSchema = z19.object({
+  access: z19.enum(["atEnd", "during"]).optional(),
+  outcomeIdentifier: z19.string().trim().min(1),
+  identifier: z19.string().trim().min(1),
+  showHide: z19.enum(["show", "hide"]).optional(),
+  content: z19.array(z19.unknown()).optional()
+});
+var assessmentItemRefViewSchema = z19.object({
+  kind: z19.literal("assessmentItemRef"),
+  identifier: z19.string().trim().min(1),
+  href: z19.string().optional(),
+  categories: z19.array(z19.string()).optional(),
+  fixed: z19.boolean().optional(),
+  required: z19.boolean().optional(),
+  preConditions: z19.array(rpExpressionSchema).optional(),
+  branchRules: z19.array(branchRuleSchema).optional(),
+  itemSessionControl: itemSessionControlSchema.optional(),
+  timeLimits: timeLimitsSchema.optional(),
+  weights: z19.array(weightSchema).optional(),
+  templateDefaults: z19.array(templateDefaultSchema).optional()
+});
+var assessmentSectionFlags = {
+  title: z19.string().trim().min(1).optional(),
+  visible: z19.boolean().optional(),
+  fixed: z19.boolean().optional(),
+  required: z19.boolean().optional(),
+  keepTogether: z19.boolean().optional(),
+  selection: selectionSchema.optional(),
+  ordering: orderingSchema.optional(),
+  preConditions: z19.array(rpExpressionSchema).optional(),
+  branchRules: z19.array(branchRuleSchema).optional(),
+  itemSessionControl: itemSessionControlSchema.optional(),
+  timeLimits: timeLimitsSchema.optional()
+};
+var testPartLevel = {
+  preConditions: z19.array(rpExpressionSchema).optional(),
+  branchRules: z19.array(branchRuleSchema).optional(),
+  itemSessionControl: itemSessionControlSchema.optional(),
+  timeLimits: timeLimitsSchema.optional()
+};
+function makeAssessmentTestSchema(itemRefSchema) {
+  const assessmentSectionSchema = z19.lazy(() => z19.object({
+    kind: z19.literal("assessmentSection"),
+    identifier: z19.string().trim().min(1),
+    ...assessmentSectionFlags,
+    children: z19.array(z19.union([assessmentSectionSchema, itemRefSchema]))
+  }));
+  const testPartSchema = z19.object({
+    identifier: z19.string().trim().min(1),
+    navigationMode: z19.enum(["linear", "nonlinear"]),
+    submissionMode: z19.enum(["individual", "simultaneous"]),
+    ...testPartLevel,
+    assessmentSections: z19.array(assessmentSectionSchema)
+  });
+  const assessmentTestSchema = z19.object({
+    identifier: z19.string().trim().min(1),
+    title: z19.string().trim().min(1).optional(),
+    outcomeDeclarations: z19.array(outcomeDeclarationSchema).optional(),
+    timeLimits: timeLimitsSchema.optional(),
+    testParts: z19.array(testPartSchema),
+    outcomeProcessing: outcomeProcessingSchema.optional(),
+    testFeedbacks: z19.array(testFeedbackSchema).optional()
+  });
+  return { assessmentSectionSchema, testPartSchema, assessmentTestSchema };
+}
+var assessmentTestViewSchema = makeAssessmentTestSchema(assessmentItemRefViewSchema).assessmentTestSchema;
 
 // src/index.ts
 var qtiReactPackageName = "@conform-ed/qti-react";
@@ -6791,14 +6979,19 @@ export {
   v0InteractionKinds,
   v0ContentModel,
   uploadInteraction,
+  timeLimitsSchema,
   textOf,
   textEntryInteraction,
+  testFeedbackSchema,
   stimulusContentFromNormalized,
   sliderInteraction,
   serializePciMarkup,
+  selectionSchema,
   selectPointInteraction,
   scoreResponse,
   sanitizeAttributes,
+  rpScalarSchema,
+  rpExpressionSchema,
   resolveTemplate,
   resolvePnpActivation,
   resolveCatalogSupports,
@@ -6813,16 +7006,25 @@ export {
   pciResponseToValue,
   parsePoint,
   parseCoords,
+  outcomeRuleSchema,
+  outcomeProcessingSchema,
+  outcomeDeclarationSchema,
+  outcomeConditionBranchSchema,
+  orderingSchema,
   orderInteraction,
   mulberry32,
   mountPci,
   mediaInteraction,
+  matchTableSchema,
   matchInteraction,
   matchCorrect,
   mapResponsePoint,
   mapResponse,
+  makeAssessmentTestSchema,
+  itemSessionControlSchema,
   isInteractionKind,
   isAllowedFlowElement,
+  interpolationTableSchema,
   inlineChoiceInteraction,
   hottextInteraction,
   hotspotInteraction,
@@ -6836,6 +7038,7 @@ export {
   executeTemplateProcessing,
   executeResponseProcessing,
   endAttemptInteraction,
+  effectiveItemScore,
   drawingInteraction,
   defineInteraction,
   createTestSessionStore,
@@ -6849,9 +7052,13 @@ export {
   collectResponseViolations,
   collectInteractionConstraints,
   choiceInteraction,
+  cardinalitySchema,
+  branchRuleSchema,
   associateInteraction,
+  assessmentTestViewSchema,
   assessmentTestViewFromNormalized,
   assessmentItemViewFromNormalized,
+  assessmentItemRefViewSchema,
   applyCorrectResponseOverrides,
   UploadReferenceSkin,
   TextEntryReferenceSkin,

package/dist/item-score.d.ts

@@ -0,0 +1,17 @@
+import type { ScoreResult } from "./types";
+export interface EffectiveItemScore {
+    readonly raw: number;
+    readonly max: number;
+    /** True when SCORE came from the RP outcomes of record rather than per-variable scoring. */
+    readonly fromOutcomes: boolean;
+}
+/**
+ * The item score of record (QTI): a numeric SCORE outcome from response processing is
+ * authoritative — PCI/RP-scored items (e.g. math-entry) have no per-variable
+ * correctResponse basis, so their standard scores read 0. Summed per-variable standard
+ * scoring is the fallback for items without RP. MAXSCORE follows the same precedence.
+ *
+ * Pure and framework-light: client and server (authoritative finalize) share it so the
+ * grade of record is derived identically on both sides.
+ */
+export declare function effectiveItemScore(scores: readonly ScoreResult[], outcomes: Readonly<Record<string, unknown>>): EffectiveItemScore;

package/dist/rp/schema.d.ts

@@ -0,0 +1,116 @@
+/**
+ * Zod mirrors of the Response-Processing view types (./types.ts). conform-ed owns the
+ * QTI view *types*; this is the validation surface that sits beside them — reusable for
+ * import/parse validation and kept honest against the types it mirrors. React-free.
+ *
+ * The expression union is deliberately permissive (`kind: z.string()`), exactly like
+ * `RpExpressionView`: kinds the interpreter does not implement still validate structurally
+ * and surface as `unsupported-rp` issues at evaluation time rather than being rejected here.
+ *
+ * The recursive schema is annotated against an explicit interface (`RpExpressionNode`); under
+ * `exactOptionalPropertyTypes` zod emits `T | undefined` optionals, so `z.infer` is a
+ * superset of the hand-written views (every view value parses — verified in the schema
+ * tests against real view samples). Callers that need the exact view shape map explicitly.
+ */
+import { z } from "zod";
+import type { RpScalar } from "./types";
+/** string | number | boolean — the QTI scalar value space (NULL is modelled by absence). */
+export declare const rpScalarSchema: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>;
+/**
+ * The inferred shape of `rpExpressionSchema` — a faithful, recursive mirror of
+ * `RpExpressionView` with zod's `T | undefined` optionals. Declared explicitly (and the
+ * schema is annotated with it) because zod's getter-based recursion degrades the recursive
+ * `expressions` field to `Record<string, unknown>` under `z.infer`; the `z.lazy` + interface
+ * form keeps the type precise (the expression-builder authoring relies on it).
+ */
+export interface RpExpressionNode {
+    readonly kind: string;
+    readonly identifier?: string | undefined;
+    readonly baseType?: string | undefined;
+    readonly value?: RpScalar | undefined;
+    readonly expressions?: readonly RpExpressionNode[] | undefined;
+    readonly min?: number | string | undefined;
+    readonly max?: number | string | undefined;
+    readonly step?: number | string | undefined;
+    readonly toleranceMode?: "exact" | "absolute" | "relative" | undefined;
+    readonly tolerance?: readonly (number | string)[] | undefined;
+    readonly includeLowerBound?: boolean | undefined;
+    readonly includeUpperBound?: boolean | undefined;
+    readonly n?: number | string | undefined;
+    readonly name?: string | undefined;
+    readonly roundingMode?: "decimalPlaces" | "significantFigures" | undefined;
+    readonly figures?: number | string | undefined;
+    readonly numberRepeats?: number | string | undefined;
+    readonly pattern?: string | undefined;
+    readonly caseSensitive?: boolean | undefined;
+    readonly substring?: boolean | undefined;
+    readonly shape?: string | undefined;
+    readonly coords?: string | undefined;
+    readonly variableIdentifier?: string | undefined;
+    readonly outcomeIdentifier?: string | undefined;
+    readonly weightIdentifier?: string | undefined;
+    readonly sectionIdentifier?: string | undefined;
+    readonly includeCategory?: string | readonly string[] | undefined;
+    readonly excludeCategory?: string | readonly string[] | undefined;
+    readonly class?: string | undefined;
+    readonly definition?: string | undefined;
+    readonly fieldIdentifier?: string | undefined;
+}
+export declare const cardinalitySchema: z.ZodEnum<{
+    multiple: "multiple";
+    ordered: "ordered";
+    record: "record";
+    single: "single";
+}>;
+/** The recursive expression schema (`z.lazy` recursion; annotated for a precise `z.infer`). */
+export declare const rpExpressionSchema: z.ZodType<RpExpressionNode>;
+export declare const matchTableSchema: z.ZodObject<{
+    defaultValue: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>;
+    matchTableEntries: z.ZodArray<z.ZodObject<{
+        sourceValue: z.ZodNumber;
+        targetValue: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const interpolationTableSchema: z.ZodObject<{
+    defaultValue: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>;
+    interpolationTableEntries: z.ZodArray<z.ZodObject<{
+        sourceValue: z.ZodNumber;
+        targetValue: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>;
+        includeBoundary: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const outcomeDeclarationSchema: z.ZodObject<{
+    identifier: z.ZodString;
+    cardinality: z.ZodEnum<{
+        multiple: "multiple";
+        ordered: "ordered";
+        record: "record";
+        single: "single";
+    }>;
+    baseType: z.ZodOptional<z.ZodString>;
+    defaultValue: z.ZodOptional<z.ZodObject<{
+        values: z.ZodArray<z.ZodObject<{
+            value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    matchTable: z.ZodOptional<z.ZodObject<{
+        defaultValue: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>;
+        matchTableEntries: z.ZodArray<z.ZodObject<{
+            sourceValue: z.ZodNumber;
+            targetValue: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    interpolationTable: z.ZodOptional<z.ZodObject<{
+        defaultValue: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>;
+        interpolationTableEntries: z.ZodArray<z.ZodObject<{
+            sourceValue: z.ZodNumber;
+            targetValue: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>;
+            includeBoundary: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    normalMaximum: z.ZodOptional<z.ZodNumber>;
+    normalMinimum: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export type RpScalarSchema = z.infer<typeof rpScalarSchema>;
+export type RpExpressionSchema = z.infer<typeof rpExpressionSchema>;
+export type OutcomeDeclarationSchema = z.infer<typeof outcomeDeclarationSchema>;

package/dist/test/schema.d.ts

@@ -0,0 +1,192 @@
+/**
+ * Zod mirrors of the `assessmentTest` structural views (./types.ts) — the shared QTI
+ * atoms (`timeLimits`, `itemSessionControl`, `selection`, `ordering`, `branchRule`,
+ * test-level outcome processing/feedback) and the recursive structure
+ * (`assessmentSection` / `testPart` / `assessmentTest`).
+ *
+ * The structure is exposed as a **factory parameterized by the itemRef schema** —
+ * `makeAssessmentTestSchema(itemRefSchema)` — because the only thing that varies between
+ * delivery (an `href`) and authoring (an `itemVersionId`) is the item reference's identity.
+ * The ready `assessmentTestViewSchema` binds the delivery `href` itemRef; emergent binds
+ * its authoring itemRef. React-free; see ../rp/schema.ts for the RP-level mirrors.
+ */
+import { z } from "zod";
+import { type OutcomeDeclarationSchema, type RpExpressionSchema } from "../rp/schema";
+/** `timeLimits` (seconds); the controller enforces these under its injected clock. */
+export declare const timeLimitsSchema: z.ZodObject<{
+    minTime: z.ZodOptional<z.ZodNumber>;
+    maxTime: z.ZodOptional<z.ZodNumber>;
+    allowLateSubmission: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+/** `itemSessionControl`: per-level overrides cascading testPart → section → itemRef. */
+export declare const itemSessionControlSchema: z.ZodObject<{
+    maxAttempts: z.ZodOptional<z.ZodNumber>;
+    showFeedback: z.ZodOptional<z.ZodBoolean>;
+    allowReview: z.ZodOptional<z.ZodBoolean>;
+    showSolution: z.ZodOptional<z.ZodBoolean>;
+    allowComment: z.ZodOptional<z.ZodBoolean>;
+    allowSkipping: z.ZodOptional<z.ZodBoolean>;
+    validateResponses: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+/** `selection`: how many children to draw, optionally with replacement (§4.2.6). */
+export declare const selectionSchema: z.ZodObject<{
+    select: z.ZodNumber;
+    withReplacement: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+/** `ordering`: whether the surviving children are shuffled (§4.2.7). */
+export declare const orderingSchema: z.ZodObject<{
+    shuffle: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export type TimeLimitsSchema = z.infer<typeof timeLimitsSchema>;
+export type ItemSessionControlSchema = z.infer<typeof itemSessionControlSchema>;
+export type SelectionSchema = z.infer<typeof selectionSchema>;
+export type OrderingSchema = z.infer<typeof orderingSchema>;
+/** `branchRule`: a target identifier (or EXIT_*) gated by a boolean expression. */
+export declare const branchRuleSchema: z.ZodObject<{
+    target: z.ZodString;
+    expression: z.ZodType<import("../rp/schema").RpExpressionNode, unknown, z.core.$ZodTypeInternals<import("../rp/schema").RpExpressionNode, unknown>>;
+}, z.core.$strip>;
+export type BranchRuleSchema = z.infer<typeof branchRuleSchema>;
+/** A gate plus its nested rules (`outcomeIf` / `outcomeElseIf`); see `OutcomeRuleNode`. */
+export interface OutcomeConditionBranchNode {
+    readonly expression: RpExpressionSchema;
+    readonly rules: readonly OutcomeRuleNode[];
+}
+/**
+ * The recursive outcome-rule shape (a faithful mirror of `OutcomeRuleView` with zod's
+ * `T | undefined` optionals). Declared explicitly so `z.infer` stays precise through the
+ * recursion (the getter form degrades nested rules to `Record<string, unknown>`).
+ */
+export interface OutcomeRuleNode {
+    readonly kind: string;
+    readonly identifier?: string | undefined;
+    readonly expression?: RpExpressionSchema | undefined;
+    readonly rules?: readonly OutcomeRuleNode[] | undefined;
+    readonly outcomeIf?: OutcomeConditionBranchNode | undefined;
+    readonly outcomeElseIfs?: readonly OutcomeConditionBranchNode[] | undefined;
+    readonly outcomeElse?: {
+        readonly rules: readonly OutcomeRuleNode[];
+    } | undefined;
+}
+/** One `outcomeIf` / `outcomeElseIf` branch: a gate plus its nested rules. */
+export declare const outcomeConditionBranchSchema: z.ZodType<OutcomeConditionBranchNode>;
+/** A recursive outcome rule (mirrors `OutcomeRuleView`); `kind` stays permissive. */
+export declare const outcomeRuleSchema: z.ZodType<OutcomeRuleNode>;
+export declare const outcomeProcessingSchema: z.ZodObject<{
+    rules: z.ZodArray<z.ZodType<OutcomeRuleNode, unknown, z.core.$ZodTypeInternals<OutcomeRuleNode, unknown>>>;
+}, z.core.$strip>;
+export type OutcomeProcessingSchema = z.infer<typeof outcomeProcessingSchema>;
+/**
+ * `testFeedback` — the scalar attributes are mirrored; the `content` body is accepted
+ * opaquely (BodyNode is the item runtime's content model, not authored at the test level).
+ */
+export declare const testFeedbackSchema: z.ZodObject<{
+    access: z.ZodOptional<z.ZodEnum<{
+        atEnd: "atEnd";
+        during: "during";
+    }>>;
+    outcomeIdentifier: z.ZodString;
+    identifier: z.ZodString;
+    showHide: z.ZodOptional<z.ZodEnum<{
+        hide: "hide";
+        show: "show";
+    }>>;
+    content: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
+}, z.core.$strip>;
+export type TestFeedbackSchema = z.infer<typeof testFeedbackSchema>;
+/** The delivery `assessmentItemRef` (`href` identity) — the ready view itemRef. */
+export declare const assessmentItemRefViewSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"assessmentItemRef">;
+    identifier: z.ZodString;
+    href: z.ZodOptional<z.ZodString>;
+    categories: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    fixed: z.ZodOptional<z.ZodBoolean>;
+    required: z.ZodOptional<z.ZodBoolean>;
+    preConditions: z.ZodOptional<z.ZodArray<z.ZodType<import("../rp/schema").RpExpressionNode, unknown, z.core.$ZodTypeInternals<import("../rp/schema").RpExpressionNode, unknown>>>>;
+    branchRules: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        target: z.ZodString;
+        expression: z.ZodType<import("../rp/schema").RpExpressionNode, unknown, z.core.$ZodTypeInternals<import("../rp/schema").RpExpressionNode, unknown>>;
+    }, z.core.$strip>>>;
+    itemSessionControl: z.ZodOptional<z.ZodObject<{
+        maxAttempts: z.ZodOptional<z.ZodNumber>;
+        showFeedback: z.ZodOptional<z.ZodBoolean>;
+        allowReview: z.ZodOptional<z.ZodBoolean>;
+        showSolution: z.ZodOptional<z.ZodBoolean>;
+        allowComment: z.ZodOptional<z.ZodBoolean>;
+        allowSkipping: z.ZodOptional<z.ZodBoolean>;
+        validateResponses: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>;
+    timeLimits: z.ZodOptional<z.ZodObject<{
+        minTime: z.ZodOptional<z.ZodNumber>;
+        maxTime: z.ZodOptional<z.ZodNumber>;
+        allowLateSubmission: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>;
+    weights: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        identifier: z.ZodString;
+        value: z.ZodNumber;
+    }, z.core.$strip>>>;
+    templateDefaults: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        templateIdentifier: z.ZodString;
+        expression: z.ZodType<import("../rp/schema").RpExpressionNode, unknown, z.core.$ZodTypeInternals<import("../rp/schema").RpExpressionNode, unknown>>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+/**
+ * The recursive section shape, parameterized by the injected itemRef's inferred type.
+ * Optionals carry `| undefined` and arrays are `readonly` so this matches zod's object
+ * output exactly — letting the `z.lazy` section schema below be annotated `z.ZodType<…>`
+ * (a getter cannot self-infer once a generic itemRef joins the `children` union).
+ */
+export interface AssessmentSectionNode<TItemRef> {
+    readonly kind: "assessmentSection";
+    readonly identifier: string;
+    readonly title?: string | undefined;
+    readonly visible?: boolean | undefined;
+    readonly fixed?: boolean | undefined;
+    readonly required?: boolean | undefined;
+    readonly keepTogether?: boolean | undefined;
+    readonly selection?: SelectionSchema | undefined;
+    readonly ordering?: OrderingSchema | undefined;
+    readonly preConditions?: readonly RpExpressionSchema[] | undefined;
+    readonly branchRules?: readonly BranchRuleSchema[] | undefined;
+    readonly itemSessionControl?: ItemSessionControlSchema | undefined;
+    readonly timeLimits?: TimeLimitsSchema | undefined;
+    readonly children: ReadonlyArray<AssessmentSectionNode<TItemRef> | TItemRef>;
+}
+/** A test part: navigation/submission modes plus the cascade levels and its sections. */
+export interface TestPartNode<TItemRef> {
+    readonly identifier: string;
+    readonly navigationMode: "linear" | "nonlinear";
+    readonly submissionMode: "individual" | "simultaneous";
+    readonly preConditions?: readonly RpExpressionSchema[] | undefined;
+    readonly branchRules?: readonly BranchRuleSchema[] | undefined;
+    readonly itemSessionControl?: ItemSessionControlSchema | undefined;
+    readonly timeLimits?: TimeLimitsSchema | undefined;
+    readonly assessmentSections: readonly AssessmentSectionNode<TItemRef>[];
+}
+/** The whole `assessmentTest`: declarations/processing/feedback plus the ordered parts. */
+export interface AssessmentTestNode<TItemRef> {
+    readonly identifier: string;
+    readonly title?: string | undefined;
+    readonly outcomeDeclarations?: readonly OutcomeDeclarationSchema[] | undefined;
+    readonly timeLimits?: TimeLimitsSchema | undefined;
+    readonly testParts: readonly TestPartNode<TItemRef>[];
+    readonly outcomeProcessing?: OutcomeProcessingSchema | undefined;
+    readonly testFeedbacks?: readonly TestFeedbackSchema[] | undefined;
+}
+/** The schema bundle the factory returns (each level parameterized by the itemRef type). */
+export interface AssessmentTestSchemas<TItemRef> {
+    readonly assessmentSectionSchema: z.ZodType<AssessmentSectionNode<TItemRef>>;
+    readonly testPartSchema: z.ZodType<TestPartNode<TItemRef>>;
+    readonly assessmentTestSchema: z.ZodType<AssessmentTestNode<TItemRef>>;
+}
+/**
+ * Build the recursive `assessmentTest` schema around a caller-supplied itemRef schema.
+ * Sections nest sections-or-itemRefs through `children` (recursion via `z.lazy`); `z.infer`
+ * follows the recursion and carries the injected itemRef's inferred type. The explicit
+ * return type keeps the package's `isolatedDeclarations` build able to emit the bundle.
+ */
+export declare function makeAssessmentTestSchema<ItemRef extends z.ZodType>(itemRefSchema: ItemRef): AssessmentTestSchemas<z.infer<ItemRef>>;
+/** The ready delivery-view schema: the recursive structure over the `href` itemRef. */
+export declare const assessmentTestViewSchema: z.ZodType<AssessmentTestNode<AssessmentItemRefViewSchema>>;
+export type AssessmentItemRefViewSchema = z.infer<typeof assessmentItemRefViewSchema>;
+export type AssessmentTestViewSchema = z.infer<typeof assessmentTestViewSchema>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@conform-ed/qti-react",
-  "version": "0.0.18",
+  "version": "0.0.20",
   "files": [
     "src",
     "dist"
@@ -30,11 +30,11 @@
     "xspattern": "^3.1.0"
   },
   "devDependencies": {
-    "@conform-ed/contracts": "0.0.18",
-    "@conform-ed/qti-xml": "0.0.18",
+    "@conform-ed/contracts": "0.0.20",
+    "@conform-ed/qti-xml": "0.0.20",
     "@types/react": "^19.2.17",
     "@types/react-dom": "^19",
-    "happy-dom": "^20.10.2",
+    "happy-dom": "^20.10.3",
     "react": "^19.2.7",
     "react-dom": "^19"
   },