@conform-ed/qti-react 0.0.19 → 0.0.21

package/dist/headless.d.ts

@@ -16,10 +16,12 @@ export { referenceInteractionKinds, reportItemCapability, type ItemCapabilityOpt
 export { foldString, mapResponse, matchCorrect, mapResponsePoint, scoreResponse } from "./response-processing";
 export { effectiveItemScore, type EffectiveItemScore } from "./item-score";
 export { applyCorrectResponseOverrides, collectRpIssues, collectTemplateIssues, executeResponseProcessing, executeTemplateProcessing, mulberry32, resolveTemplate, } from "./rp";
-export type { CustomOperatorImplementation, OutcomeDeclarationView, OutcomeValue, ResponseNormalization, ResponseProcessingContext, ResponseProcessingResult, ResponseProcessingView, TemplateDeclarationView, } from "./rp";
+export type { CustomOperatorImplementation, InterpolationTableView, MatchTableView, MaybeRpValue, OutcomeDeclarationView, OutcomeValue, ResponseNormalization, ResponseProcessingContext, ResponseProcessingResult, ResponseProcessingView, RpConditionBranch, RpExpressionView, RpRuleView, RpScalar, RpValue, TemplateDeclarationView, } from "./rp";
 export { createAttemptStore, type AttemptSnapshot, type AttemptStore, type AttemptStoreOptions } from "./store";
 export { createTestController, type TestController, type TestSessionState } from "./test";
 export type { CapabilityIssue, CapabilityIssueType, CapabilityReport } from "./capability";
 export type { AssessmentItemView, AssessmentStimulusRefView, BodyNode, InteractionNode, StimulusContentView, XmlContentNode, } from "./runtime";
-export type { AssessmentTestView } from "./test";
+export type { AssessmentItemRefView, AssessmentSectionView, AssessmentTestView, TestPartView } from "./test";
 export type { Cardinality, ResponseDeclarationView, ResponseValue, ScoreResult } from "./types";
+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/headless.js

@@ -4780,16 +4780,201 @@ function createTestSessionStore(controller, options) {
     })
   };
 }
+// src/rp/schema.ts
+import { z as z2 } from "zod";
+var rpScalarSchema = z2.union([z2.string(), z2.number(), z2.boolean()]);
+var numberOrRef = z2.union([z2.number(), z2.string()]);
+var categoryFilter = z2.union([z2.string(), z2.array(z2.string())]);
+var cardinalitySchema = z2.enum(["single", "multiple", "ordered", "record"]);
+var rpExpressionSchema = z2.lazy(() => z2.object({
+  kind: z2.string(),
+  identifier: z2.string().optional(),
+  baseType: z2.string().optional(),
+  value: rpScalarSchema.optional(),
+  expressions: z2.array(rpExpressionSchema).optional(),
+  min: numberOrRef.optional(),
+  max: numberOrRef.optional(),
+  step: numberOrRef.optional(),
+  toleranceMode: z2.enum(["exact", "absolute", "relative"]).optional(),
+  tolerance: z2.array(numberOrRef).optional(),
+  includeLowerBound: z2.boolean().optional(),
+  includeUpperBound: z2.boolean().optional(),
+  n: numberOrRef.optional(),
+  name: z2.string().optional(),
+  roundingMode: z2.enum(["decimalPlaces", "significantFigures"]).optional(),
+  figures: numberOrRef.optional(),
+  numberRepeats: numberOrRef.optional(),
+  pattern: z2.string().optional(),
+  caseSensitive: z2.boolean().optional(),
+  substring: z2.boolean().optional(),
+  shape: z2.string().optional(),
+  coords: z2.string().optional(),
+  variableIdentifier: z2.string().optional(),
+  outcomeIdentifier: z2.string().optional(),
+  weightIdentifier: z2.string().optional(),
+  sectionIdentifier: z2.string().optional(),
+  includeCategory: categoryFilter.optional(),
+  excludeCategory: categoryFilter.optional(),
+  class: z2.string().optional(),
+  definition: z2.string().optional(),
+  fieldIdentifier: z2.string().optional()
+}));
+var matchTableSchema = z2.object({
+  defaultValue: rpScalarSchema.optional(),
+  matchTableEntries: z2.array(z2.object({ sourceValue: z2.number(), targetValue: rpScalarSchema }))
+});
+var interpolationTableSchema = z2.object({
+  defaultValue: rpScalarSchema.optional(),
+  interpolationTableEntries: z2.array(z2.object({
+    sourceValue: z2.number(),
+    targetValue: rpScalarSchema,
+    includeBoundary: z2.boolean().optional()
+  }))
+});
+var outcomeDeclarationSchema = z2.object({
+  identifier: z2.string(),
+  cardinality: cardinalitySchema,
+  baseType: z2.string().optional(),
+  defaultValue: z2.object({ values: z2.array(z2.object({ value: rpScalarSchema })) }).optional(),
+  matchTable: matchTableSchema.optional(),
+  interpolationTable: interpolationTableSchema.optional(),
+  normalMaximum: z2.number().optional(),
+  normalMinimum: z2.number().optional()
+});
+// src/test/schema.ts
+import { z as z3 } from "zod";
+var timeLimitsSchema = z3.object({
+  minTime: z3.number().nonnegative().optional(),
+  maxTime: z3.number().nonnegative().optional(),
+  allowLateSubmission: z3.boolean().optional()
+});
+var itemSessionControlSchema = z3.object({
+  maxAttempts: z3.number().int().nonnegative().optional(),
+  showFeedback: z3.boolean().optional(),
+  allowReview: z3.boolean().optional(),
+  showSolution: z3.boolean().optional(),
+  allowComment: z3.boolean().optional(),
+  allowSkipping: z3.boolean().optional(),
+  validateResponses: z3.boolean().optional()
+});
+var selectionSchema = z3.object({
+  select: z3.number().int().nonnegative(),
+  withReplacement: z3.boolean().optional()
+});
+var orderingSchema = z3.object({ shuffle: z3.boolean().optional() });
+var branchRuleSchema = z3.object({
+  target: z3.string().trim().min(1),
+  expression: rpExpressionSchema
+});
+var weightSchema = z3.object({ identifier: z3.string().trim().min(1), value: z3.number() });
+var templateDefaultSchema = z3.object({
+  templateIdentifier: z3.string().trim().min(1),
+  expression: rpExpressionSchema
+});
+var outcomeConditionBranchSchema = z3.lazy(() => z3.object({
+  expression: rpExpressionSchema,
+  rules: z3.array(outcomeRuleSchema)
+}));
+var outcomeRuleSchema = z3.lazy(() => z3.object({
+  kind: z3.string(),
+  identifier: z3.string().optional(),
+  expression: rpExpressionSchema.optional(),
+  rules: z3.array(outcomeRuleSchema).optional(),
+  outcomeIf: outcomeConditionBranchSchema.optional(),
+  outcomeElseIfs: z3.array(outcomeConditionBranchSchema).optional(),
+  outcomeElse: z3.object({ rules: z3.array(outcomeRuleSchema) }).optional()
+}));
+var outcomeProcessingSchema = z3.object({ rules: z3.array(outcomeRuleSchema) });
+var testFeedbackSchema = z3.object({
+  access: z3.enum(["atEnd", "during"]).optional(),
+  outcomeIdentifier: z3.string().trim().min(1),
+  identifier: z3.string().trim().min(1),
+  showHide: z3.enum(["show", "hide"]).optional(),
+  content: z3.array(z3.unknown()).optional()
+});
+var assessmentItemRefViewSchema = z3.object({
+  kind: z3.literal("assessmentItemRef"),
+  identifier: z3.string().trim().min(1),
+  href: z3.string().optional(),
+  categories: z3.array(z3.string()).optional(),
+  fixed: z3.boolean().optional(),
+  required: z3.boolean().optional(),
+  preConditions: z3.array(rpExpressionSchema).optional(),
+  branchRules: z3.array(branchRuleSchema).optional(),
+  itemSessionControl: itemSessionControlSchema.optional(),
+  timeLimits: timeLimitsSchema.optional(),
+  weights: z3.array(weightSchema).optional(),
+  templateDefaults: z3.array(templateDefaultSchema).optional()
+});
+var assessmentSectionFlags = {
+  title: z3.string().trim().min(1).optional(),
+  visible: z3.boolean().optional(),
+  fixed: z3.boolean().optional(),
+  required: z3.boolean().optional(),
+  keepTogether: z3.boolean().optional(),
+  selection: selectionSchema.optional(),
+  ordering: orderingSchema.optional(),
+  preConditions: z3.array(rpExpressionSchema).optional(),
+  branchRules: z3.array(branchRuleSchema).optional(),
+  itemSessionControl: itemSessionControlSchema.optional(),
+  timeLimits: timeLimitsSchema.optional()
+};
+var testPartLevel = {
+  preConditions: z3.array(rpExpressionSchema).optional(),
+  branchRules: z3.array(branchRuleSchema).optional(),
+  itemSessionControl: itemSessionControlSchema.optional(),
+  timeLimits: timeLimitsSchema.optional()
+};
+function makeAssessmentTestSchema(itemRefSchema) {
+  const assessmentSectionSchema = z3.lazy(() => z3.object({
+    kind: z3.literal("assessmentSection"),
+    identifier: z3.string().trim().min(1),
+    ...assessmentSectionFlags,
+    children: z3.array(z3.union([assessmentSectionSchema, itemRefSchema]))
+  }));
+  const testPartSchema = z3.object({
+    identifier: z3.string().trim().min(1),
+    navigationMode: z3.enum(["linear", "nonlinear"]),
+    submissionMode: z3.enum(["individual", "simultaneous"]),
+    ...testPartLevel,
+    assessmentSections: z3.array(assessmentSectionSchema)
+  });
+  const assessmentTestSchema = z3.object({
+    identifier: z3.string().trim().min(1),
+    title: z3.string().trim().min(1).optional(),
+    outcomeDeclarations: z3.array(outcomeDeclarationSchema).optional(),
+    timeLimits: timeLimitsSchema.optional(),
+    testParts: z3.array(testPartSchema),
+    outcomeProcessing: outcomeProcessingSchema.optional(),
+    testFeedbacks: z3.array(testFeedbackSchema).optional()
+  });
+  return { assessmentSectionSchema, testPartSchema, assessmentTestSchema };
+}
+var assessmentTestViewSchema = makeAssessmentTestSchema(assessmentItemRefViewSchema).assessmentTestSchema;
 export {
+  timeLimitsSchema,
+  testFeedbackSchema,
   stimulusContentFromNormalized,
+  selectionSchema,
   scoreResponse,
+  rpScalarSchema,
+  rpExpressionSchema,
   resolveTemplate,
   reportItemCapability,
   referenceInteractionKinds,
+  outcomeRuleSchema,
+  outcomeProcessingSchema,
+  outcomeDeclarationSchema,
+  outcomeConditionBranchSchema,
+  orderingSchema,
   mulberry32,
+  matchTableSchema,
   matchCorrect,
   mapResponsePoint,
   mapResponse,
+  makeAssessmentTestSchema,
+  itemSessionControlSchema,
+  interpolationTableSchema,
   foldString,
   executeTemplateProcessing,
   executeResponseProcessing,
@@ -4798,7 +4983,11 @@ export {
   createAttemptStore,
   collectTemplateIssues,
   collectRpIssues,
+  cardinalitySchema,
+  branchRuleSchema,
+  assessmentTestViewSchema,
   assessmentTestViewFromNormalized,
   assessmentItemViewFromNormalized,
+  assessmentItemRefViewSchema,
   applyCorrectResponseOverrides
 };

package/dist/index.d.ts

@@ -16,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

@@ -6800,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";
@@ -6808,14 +6979,19 @@ export {
   v0InteractionKinds,
   v0ContentModel,
   uploadInteraction,
+  timeLimitsSchema,
   textOf,
   textEntryInteraction,
+  testFeedbackSchema,
   stimulusContentFromNormalized,
   sliderInteraction,
   serializePciMarkup,
+  selectionSchema,
   selectPointInteraction,
   scoreResponse,
   sanitizeAttributes,
+  rpScalarSchema,
+  rpExpressionSchema,
   resolveTemplate,
   resolvePnpActivation,
   resolveCatalogSupports,
@@ -6830,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,
@@ -6867,9 +7052,13 @@ export {
   collectResponseViolations,
   collectInteractionConstraints,
   choiceInteraction,
+  cardinalitySchema,
+  branchRuleSchema,
   associateInteraction,
+  assessmentTestViewSchema,
   assessmentTestViewFromNormalized,
   assessmentItemViewFromNormalized,
+  assessmentItemRefViewSchema,
   applyCorrectResponseOverrides,
   UploadReferenceSkin,
   TextEntryReferenceSkin,

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.19",
+  "version": "0.0.21",
   "files": [
     "src",
     "dist"
@@ -30,8 +30,8 @@
     "xspattern": "^3.1.0"
   },
   "devDependencies": {
-    "@conform-ed/contracts": "0.0.19",
-    "@conform-ed/qti-xml": "0.0.19",
+    "@conform-ed/contracts": "0.0.21",
+    "@conform-ed/qti-xml": "0.0.21",
     "@types/react": "^19.2.17",
     "@types/react-dom": "^19",
     "happy-dom": "^20.10.3",

package/src/headless.ts

@@ -34,12 +34,20 @@ export {
 } from "./rp";
 export type {
   CustomOperatorImplementation,
+  InterpolationTableView,
+  MatchTableView,
+  MaybeRpValue,
   OutcomeDeclarationView,
   OutcomeValue,
   ResponseNormalization,
   ResponseProcessingContext,
   ResponseProcessingResult,
   ResponseProcessingView,
+  RpConditionBranch,
+  RpExpressionView,
+  RpRuleView,
+  RpScalar,
+  RpValue,
   TemplateDeclarationView,
 } from "./rp";
 export { createAttemptStore, type AttemptSnapshot, type AttemptStore, type AttemptStoreOptions } from "./store";
@@ -54,5 +62,45 @@ export type {
   StimulusContentView,
   XmlContentNode,
 } from "./runtime";
-export type { AssessmentTestView } from "./test";
+export type { AssessmentItemRefView, AssessmentSectionView, AssessmentTestView, TestPartView } from "./test";
 export type { Cardinality, ResponseDeclarationView, ResponseValue, ScoreResult } from "./types";
+
+// QTI validation surface (zod mirrors of the views above) — atoms, the recursive
+// rpExpression/outcome schemas, and the structure factory. React-free; reusable for
+// import/parse validation and parameterized for authoring deltas (emergent's itemVersionId).
+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/src/index.ts

@@ -229,3 +229,42 @@ export {
   type PnpView,
   type ResolvedCatalogSupport,
 } from "./pnp";
+
+// QTI validation surface (zod mirrors of the assessmentTest/RP views). Also exposed at
+// `@conform-ed/qti-react/headless` for server-side import/parse validation without React.
+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/src/rp/schema.ts

@@ -0,0 +1,143 @@
+/**
+ * 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 const rpScalarSchema = z.union([z.string(), z.number(), z.boolean()]);
+
+/**
+ * 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;
+}
+
+/**
+ * A numeric attribute that may also be a variable reference (§2.11.3.6 / §7.13): the
+ * random/aggregate bounds, `index`/`anyN` positions, rounding `figures`, `repeat` counts.
+ */
+const numberOrRef = z.union([z.number(), z.string()]);
+
+/** `includeCategory` / `excludeCategory` accept a single category or a list. */
+const categoryFilter = z.union([z.string(), z.array(z.string())]);
+
+export const cardinalitySchema = z.enum(["single", "multiple", "ordered", "record"]);
+
+/** The recursive expression schema (`z.lazy` recursion; annotated for a precise `z.infer`). */
+export const rpExpressionSchema: z.ZodType<RpExpressionNode> = z.lazy(() =>
+  z.object({
+    kind: z.string(),
+    identifier: z.string().optional(),
+    baseType: z.string().optional(),
+    value: rpScalarSchema.optional(),
+    expressions: z.array(rpExpressionSchema).optional(),
+    min: numberOrRef.optional(),
+    max: numberOrRef.optional(),
+    step: numberOrRef.optional(),
+    toleranceMode: z.enum(["exact", "absolute", "relative"]).optional(),
+    tolerance: z.array(numberOrRef).optional(),
+    includeLowerBound: z.boolean().optional(),
+    includeUpperBound: z.boolean().optional(),
+    n: numberOrRef.optional(),
+    name: z.string().optional(),
+    roundingMode: z.enum(["decimalPlaces", "significantFigures"]).optional(),
+    figures: numberOrRef.optional(),
+    numberRepeats: numberOrRef.optional(),
+    pattern: z.string().optional(),
+    caseSensitive: z.boolean().optional(),
+    substring: z.boolean().optional(),
+    shape: z.string().optional(),
+    coords: z.string().optional(),
+    variableIdentifier: z.string().optional(),
+    outcomeIdentifier: z.string().optional(),
+    weightIdentifier: z.string().optional(),
+    sectionIdentifier: z.string().optional(),
+    includeCategory: categoryFilter.optional(),
+    excludeCategory: categoryFilter.optional(),
+    class: z.string().optional(),
+    definition: z.string().optional(),
+    fieldIdentifier: z.string().optional(),
+  }),
+);
+
+// ---------- Outcome declarations (lookup tables) ----------
+
+export const matchTableSchema = z.object({
+  defaultValue: rpScalarSchema.optional(),
+  matchTableEntries: z.array(z.object({ sourceValue: z.number(), targetValue: rpScalarSchema })),
+});
+
+export const interpolationTableSchema = z.object({
+  defaultValue: rpScalarSchema.optional(),
+  interpolationTableEntries: z.array(
+    z.object({
+      sourceValue: z.number(),
+      targetValue: rpScalarSchema,
+      includeBoundary: z.boolean().optional(),
+    }),
+  ),
+});
+
+export const outcomeDeclarationSchema = z.object({
+  identifier: z.string(),
+  cardinality: cardinalitySchema,
+  baseType: z.string().optional(),
+  defaultValue: z.object({ values: z.array(z.object({ value: rpScalarSchema })) }).optional(),
+  matchTable: matchTableSchema.optional(),
+  interpolationTable: interpolationTableSchema.optional(),
+  normalMaximum: z.number().optional(),
+  normalMinimum: z.number().optional(),
+});
+
+export type RpScalarSchema = z.infer<typeof rpScalarSchema>;
+export type RpExpressionSchema = z.infer<typeof rpExpressionSchema>;
+export type OutcomeDeclarationSchema = z.infer<typeof outcomeDeclarationSchema>;

package/src/test/schema.ts

@@ -0,0 +1,272 @@
+/**
+ * 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 {
+  outcomeDeclarationSchema,
+  type OutcomeDeclarationSchema,
+  type RpExpressionSchema,
+  rpExpressionSchema,
+} from "../rp/schema";
+
+// ---------- Shared atoms (cascade levels: testPart → section → itemRef) ----------
+
+/** `timeLimits` (seconds); the controller enforces these under its injected clock. */
+export const timeLimitsSchema = z.object({
+  minTime: z.number().nonnegative().optional(),
+  maxTime: z.number().nonnegative().optional(),
+  allowLateSubmission: z.boolean().optional(),
+});
+
+/** `itemSessionControl`: per-level overrides cascading testPart → section → itemRef. */
+export const itemSessionControlSchema = z.object({
+  maxAttempts: z.number().int().nonnegative().optional(),
+  showFeedback: z.boolean().optional(),
+  allowReview: z.boolean().optional(),
+  showSolution: z.boolean().optional(),
+  allowComment: z.boolean().optional(),
+  allowSkipping: z.boolean().optional(),
+  validateResponses: z.boolean().optional(),
+});
+
+/** `selection`: how many children to draw, optionally with replacement (§4.2.6). */
+export const selectionSchema = z.object({
+  select: z.number().int().nonnegative(),
+  withReplacement: z.boolean().optional(),
+});
+
+/** `ordering`: whether the surviving children are shuffled (§4.2.7). */
+export const orderingSchema = z.object({ shuffle: z.boolean().optional() });
+
+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 const branchRuleSchema = z.object({
+  target: z.string().trim().min(1),
+  expression: rpExpressionSchema,
+});
+
+export type BranchRuleSchema = z.infer<typeof branchRuleSchema>;
+
+const weightSchema = z.object({ identifier: z.string().trim().min(1), value: z.number() });
+
+const templateDefaultSchema = z.object({
+  templateIdentifier: z.string().trim().min(1),
+  expression: rpExpressionSchema,
+});
+
+// ---------- Test-level outcome processing + feedback ----------
+
+/** 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 const outcomeConditionBranchSchema: z.ZodType<OutcomeConditionBranchNode> = z.lazy(() =>
+  z.object({
+    expression: rpExpressionSchema,
+    rules: z.array(outcomeRuleSchema),
+  }),
+);
+
+/** A recursive outcome rule (mirrors `OutcomeRuleView`); `kind` stays permissive. */
+export const outcomeRuleSchema: z.ZodType<OutcomeRuleNode> = z.lazy(() =>
+  z.object({
+    kind: z.string(),
+    identifier: z.string().optional(),
+    expression: rpExpressionSchema.optional(),
+    rules: z.array(outcomeRuleSchema).optional(),
+    outcomeIf: outcomeConditionBranchSchema.optional(),
+    outcomeElseIfs: z.array(outcomeConditionBranchSchema).optional(),
+    outcomeElse: z.object({ rules: z.array(outcomeRuleSchema) }).optional(),
+  }),
+);
+
+export const outcomeProcessingSchema = z.object({ rules: z.array(outcomeRuleSchema) });
+
+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 const testFeedbackSchema = z.object({
+  access: z.enum(["atEnd", "during"]).optional(),
+  outcomeIdentifier: z.string().trim().min(1),
+  identifier: z.string().trim().min(1),
+  showHide: z.enum(["show", "hide"]).optional(),
+  content: z.array(z.unknown()).optional(),
+});
+
+export type TestFeedbackSchema = z.infer<typeof testFeedbackSchema>;
+
+// ---------- The delivery itemRef (href identity) ----------
+
+/** The delivery `assessmentItemRef` (`href` identity) — the ready view itemRef. */
+export const assessmentItemRefViewSchema = z.object({
+  kind: z.literal("assessmentItemRef"),
+  identifier: z.string().trim().min(1),
+  href: z.string().optional(),
+  categories: z.array(z.string()).optional(),
+  fixed: z.boolean().optional(),
+  required: z.boolean().optional(),
+  preConditions: z.array(rpExpressionSchema).optional(),
+  branchRules: z.array(branchRuleSchema).optional(),
+  itemSessionControl: itemSessionControlSchema.optional(),
+  timeLimits: timeLimitsSchema.optional(),
+  weights: z.array(weightSchema).optional(),
+  templateDefaults: z.array(templateDefaultSchema).optional(),
+});
+
+// ---------- The recursive structure factory ----------
+
+const assessmentSectionFlags = {
+  title: z.string().trim().min(1).optional(),
+  visible: z.boolean().optional(),
+  fixed: z.boolean().optional(),
+  required: z.boolean().optional(),
+  keepTogether: z.boolean().optional(),
+  selection: selectionSchema.optional(),
+  ordering: orderingSchema.optional(),
+  preConditions: z.array(rpExpressionSchema).optional(),
+  branchRules: z.array(branchRuleSchema).optional(),
+  itemSessionControl: itemSessionControlSchema.optional(),
+  timeLimits: timeLimitsSchema.optional(),
+} as const;
+
+const testPartLevel = {
+  preConditions: z.array(rpExpressionSchema).optional(),
+  branchRules: z.array(branchRuleSchema).optional(),
+  itemSessionControl: itemSessionControlSchema.optional(),
+  timeLimits: timeLimitsSchema.optional(),
+} as const;
+
+/**
+ * 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 function makeAssessmentTestSchema<ItemRef extends z.ZodType>(
+  itemRefSchema: ItemRef,
+): AssessmentTestSchemas<z.infer<ItemRef>> {
+  const assessmentSectionSchema: z.ZodType<AssessmentSectionNode<z.infer<ItemRef>>> = z.lazy(() =>
+    z.object({
+      kind: z.literal("assessmentSection"),
+      identifier: z.string().trim().min(1),
+      ...assessmentSectionFlags,
+      children: z.array(z.union([assessmentSectionSchema, itemRefSchema])),
+    }),
+  );
+
+  const testPartSchema: z.ZodType<TestPartNode<z.infer<ItemRef>>> = z.object({
+    identifier: z.string().trim().min(1),
+    navigationMode: z.enum(["linear", "nonlinear"]),
+    submissionMode: z.enum(["individual", "simultaneous"]),
+    ...testPartLevel,
+    assessmentSections: z.array(assessmentSectionSchema),
+  });
+
+  const assessmentTestSchema: z.ZodType<AssessmentTestNode<z.infer<ItemRef>>> = z.object({
+    identifier: z.string().trim().min(1),
+    title: z.string().trim().min(1).optional(),
+    outcomeDeclarations: z.array(outcomeDeclarationSchema).optional(),
+    timeLimits: timeLimitsSchema.optional(),
+    testParts: z.array(testPartSchema),
+    outcomeProcessing: outcomeProcessingSchema.optional(),
+    testFeedbacks: z.array(testFeedbackSchema).optional(),
+  });
+
+  return { assessmentSectionSchema, testPartSchema, assessmentTestSchema };
+}
+
+/** The ready delivery-view schema: the recursive structure over the `href` itemRef. */
+export const assessmentTestViewSchema: z.ZodType<AssessmentTestNode<AssessmentItemRefViewSchema>> =
+  makeAssessmentTestSchema(assessmentItemRefViewSchema).assessmentTestSchema;
+
+export type AssessmentItemRefViewSchema = z.infer<typeof assessmentItemRefViewSchema>;
+export type AssessmentTestViewSchema = z.infer<typeof assessmentTestViewSchema>;