@conform-ed/qti-react 0.0.13 → 0.0.14

package/dist/test/types.d.ts

@@ -0,0 +1,194 @@
+/**
+ * Structural views of QTI 3 `assessmentTest` and the Test Controller's session state
+ * (ADR-0005). The controller owns the rules; everything in `TestSessionState` is plain
+ * JSON so the consumer owns persistence — store the seed and the state, replay the
+ * test.
+ */
+import type { CapabilityIssue } from "../capability";
+import type { OutcomeDeclarationView, OutcomeValue, RpExpressionView } from "../rp";
+import type { BodyNode } from "../runtime";
+export interface BranchRuleView {
+    /** A target identifier in the same test part, or EXIT_TEST / EXIT_TESTPART / EXIT_SECTION. */
+    readonly target: string;
+    readonly expression: RpExpressionView;
+}
+/**
+ * QTI `itemSessionControl`: per-level overrides cascading testPart → section → itemRef.
+ * The controller enforces `maxAttempts` and `allowSkipping`; the rest is surfaced for
+ * delivery chrome (review/solution/comment affordances are UI concerns).
+ */
+export interface ItemSessionControlView {
+    /** Attempts allowed per item; 0 means unlimited. Spec default: 1. */
+    readonly maxAttempts?: number;
+    readonly showFeedback?: boolean;
+    readonly allowReview?: boolean;
+    readonly showSolution?: boolean;
+    readonly allowComment?: boolean;
+    /** When false, the candidate must attempt the item before moving past it. */
+    readonly allowSkipping?: boolean;
+    readonly validateResponses?: boolean;
+}
+/**
+ * QTI `timeLimits` (seconds). The controller is clock-free by design (ADR-0005): these
+ * are data for the consumer's timers, which call `next()`/`end()` when time runs out.
+ */
+export interface TimeLimitsView {
+    readonly minTime?: number;
+    readonly maxTime?: number;
+    readonly allowLateSubmission?: boolean;
+}
+export interface AssessmentItemRefView {
+    readonly kind: "assessmentItemRef";
+    readonly identifier: string;
+    readonly href?: string;
+    readonly categories?: readonly string[];
+    readonly fixed?: boolean;
+    readonly required?: boolean;
+    readonly preConditions?: readonly RpExpressionView[];
+    readonly branchRules?: readonly BranchRuleView[];
+    readonly itemSessionControl?: ItemSessionControlView;
+    readonly timeLimits?: TimeLimitsView;
+    /** Named weights for `testVariables`/aggregate weighting (missing names weigh 1). */
+    readonly weights?: ReadonlyArray<{
+        readonly identifier: string;
+        readonly value: number;
+    }>;
+}
+export interface AssessmentSectionView {
+    readonly kind: "assessmentSection";
+    readonly identifier: string;
+    readonly title?: string;
+    readonly visible?: boolean;
+    readonly fixed?: boolean;
+    readonly required?: boolean;
+    readonly selection?: {
+        readonly select: number;
+        readonly withReplacement?: boolean;
+    };
+    readonly ordering?: {
+        readonly shuffle?: boolean;
+    };
+    readonly preConditions?: readonly RpExpressionView[];
+    readonly branchRules?: readonly BranchRuleView[];
+    readonly itemSessionControl?: ItemSessionControlView;
+    readonly timeLimits?: TimeLimitsView;
+    readonly children: ReadonlyArray<AssessmentSectionView | AssessmentItemRefView>;
+}
+export interface TestPartView {
+    readonly identifier: string;
+    readonly navigationMode: "linear" | "nonlinear";
+    readonly submissionMode: "individual" | "simultaneous";
+    readonly preConditions?: readonly RpExpressionView[];
+    readonly branchRules?: readonly BranchRuleView[];
+    readonly itemSessionControl?: ItemSessionControlView;
+    readonly timeLimits?: TimeLimitsView;
+    readonly assessmentSections: readonly AssessmentSectionView[];
+}
+export interface TestFeedbackView {
+    readonly access?: "atEnd" | "during";
+    readonly outcomeIdentifier: string;
+    readonly identifier: string;
+    readonly showHide?: "show" | "hide";
+    readonly content?: readonly BodyNode[];
+}
+export interface OutcomeConditionBranch {
+    readonly expression: RpExpressionView;
+    readonly rules: readonly OutcomeRuleView[];
+}
+/** One outcome rule: outcomeCondition, setOutcomeValue, or exitTest. */
+export interface OutcomeRuleView {
+    readonly kind: string;
+    readonly identifier?: string;
+    readonly expression?: RpExpressionView;
+    readonly outcomeIf?: OutcomeConditionBranch;
+    readonly outcomeElseIfs?: readonly OutcomeConditionBranch[];
+    readonly outcomeElse?: {
+        readonly rules: readonly OutcomeRuleView[];
+    };
+}
+export interface AssessmentTestView {
+    readonly identifier: string;
+    readonly title?: string;
+    readonly outcomeDeclarations?: readonly OutcomeDeclarationView[];
+    readonly timeLimits?: TimeLimitsView;
+    readonly testParts: readonly TestPartView[];
+    readonly outcomeProcessing?: {
+        readonly rules: readonly OutcomeRuleView[];
+    };
+    readonly testFeedbacks?: readonly TestFeedbackView[];
+}
+export interface TestPlanItem {
+    /** The item ref identifier — unique within the test, used as the session key. */
+    readonly key: string;
+    readonly ref: AssessmentItemRefView;
+    readonly partIdentifier: string;
+    readonly sectionPath: readonly string[];
+    /** The item's own preconditions plus its ancestor sections' (all must pass). */
+    readonly preConditions: readonly RpExpressionView[];
+    /** Effective session control: part → section → itemRef cascade over spec defaults. */
+    readonly sessionControl: Required<ItemSessionControlView>;
+    /** The item ref's own time limits (part/test limits live on their own levels). */
+    readonly timeLimits?: TimeLimitsView;
+}
+export interface TestPlanPart {
+    readonly identifier: string;
+    readonly navigationMode: "linear" | "nonlinear";
+    readonly submissionMode: "individual" | "simultaneous";
+    readonly timeLimits?: TimeLimitsView;
+    readonly items: readonly TestPlanItem[];
+}
+export interface TestPlan {
+    readonly timeLimits?: TimeLimitsView;
+    readonly parts: readonly TestPlanPart[];
+}
+export interface TestItemResult {
+    readonly outcomes: Readonly<Record<string, OutcomeValue>>;
+    /**
+     * Whether every scorable response variable matched (feeds numberCorrect /
+     * numberIncorrect). Omit when the item has nothing to be correct about.
+     */
+    readonly correct?: boolean;
+    /** The candidate gave at least one non-empty response (feeds numberResponded). */
+    readonly responded?: boolean;
+    /** Adaptive items manage their own attempt lifecycle, so maxAttempts is ignored (spec). */
+    readonly adaptive?: boolean;
+}
+export interface TestSessionState {
+    readonly status: "in-progress" | "ended";
+    readonly currentItemKey: string | null;
+    readonly itemOutcomes: Readonly<Record<string, Readonly<Record<string, OutcomeValue>>>>;
+    readonly attemptedItems: readonly string[];
+    readonly attemptCounts: Readonly<Record<string, number>>;
+    /** Items that have been the current item at least once (feeds numberPresented). */
+    readonly presentedItems: readonly string[];
+    /** Items whose latest attempt carried a response (feeds numberResponded). */
+    readonly respondedItems: readonly string[];
+    /** Items whose latest attempt was correct / incorrect (feeds numberCorrect/Incorrect). */
+    readonly correctItems: readonly string[];
+    readonly incorrectItems: readonly string[];
+    /**
+     * Results held back in simultaneous-submission parts (QTI: the part's responses are
+     * submitted together). They commit when the part is left or the test ends; until
+     * then they are invisible to outcome processing and feedback.
+     */
+    readonly pendingItemResults: Readonly<Record<string, TestItemResult>>;
+    readonly testOutcomes: Readonly<Record<string, OutcomeValue>>;
+}
+export interface TestController {
+    readonly plan: TestPlan;
+    /** Static capability issues found in outcome processing, preconditions, and branch rules. */
+    readonly issues: readonly CapabilityIssue[];
+    readonly start: () => TestSessionState;
+    readonly currentItem: (state: TestSessionState) => TestPlanItem | null;
+    readonly canMoveTo: (state: TestSessionState, itemKey: string) => boolean;
+    readonly moveTo: (state: TestSessionState, itemKey: string) => TestSessionState;
+    /** Whether `next()` would change state (false when allowSkipping blocks the move). */
+    readonly canNext: (state: TestSessionState) => boolean;
+    readonly next: (state: TestSessionState) => TestSessionState;
+    /** Attempts left for the item under its effective maxAttempts (Infinity when unlimited). */
+    readonly remainingAttempts: (state: TestSessionState, itemKey: string) => number;
+    readonly canSubmitItem: (state: TestSessionState, itemKey: string) => boolean;
+    readonly submitItem: (state: TestSessionState, itemKey: string, result: TestItemResult) => TestSessionState;
+    readonly end: (state: TestSessionState) => TestSessionState;
+    readonly visibleTestFeedbacks: (state: TestSessionState) => readonly TestFeedbackView[];
+}

package/dist/types.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Runtime view types for the headless core. These are structural views of the
+ * `@conform-ed/contracts` QTI 3.0.1 shapes — the runtime validates items with the
+ * contract schemas, but works against these narrowed types because several contract
+ * schemas are `z.lazy` (statically `any`). No React or Mantine here.
+ */
+/** One field of a record response; fields keep their runtime type (PCI JSON typing). */
+export type ResponseFieldValue = string | number | boolean | null;
+/** A record-cardinality response: named, individually-typed fields (PCI contracts). */
+export type ResponseRecordValue = Readonly<Record<string, ResponseFieldValue>>;
+/** A candidate response for one interaction, keyed in state by `responseIdentifier`. */
+export type ResponseValue = string | readonly string[] | ResponseRecordValue | null;
+/** Narrow a ResponseValue to its record variant. */
+export declare function isResponseRecord(value: ResponseValue): value is ResponseRecordValue;
+export type Cardinality = "single" | "multiple" | "ordered" | "record";
+export interface CorrectResponseView {
+    readonly values: ReadonlyArray<{
+        readonly value: string;
+    }>;
+}
+export interface MapEntryView {
+    readonly mapKey: string;
+    readonly mappedValue: number;
+    readonly caseSensitive?: boolean;
+}
+export interface MappingView {
+    readonly mapEntries: readonly MapEntryView[];
+    readonly lowerBound?: number;
+    readonly upperBound?: number;
+    readonly defaultValue?: number;
+}
+/** One scored area for point responses (QTI `areaMapEntry`). */
+export interface AreaMapEntryView {
+    readonly shape: string;
+    readonly coords: readonly number[];
+    readonly mappedValue: number;
+}
+export interface AreaMappingView {
+    readonly areaMapEntries: readonly AreaMapEntryView[];
+    readonly lowerBound?: number;
+    readonly upperBound?: number;
+    readonly defaultValue?: number;
+}
+export interface ResponseDeclarationView {
+    readonly identifier: string;
+    readonly cardinality: Cardinality;
+    readonly baseType?: string;
+    readonly correctResponse?: CorrectResponseView;
+    readonly mapping?: MappingView;
+    readonly areaMapping?: AreaMappingView;
+}
+/** The scored outcome for one response variable. */
+export interface ScoreResult {
+    readonly identifier: string;
+    readonly score: number;
+    readonly maxScore: number;
+    readonly correct: boolean;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@conform-ed/qti-react",
-  "version": "0.0.13",
+  "version": "0.0.14",
   "files": [
     "src",
     "dist"
@@ -9,16 +9,16 @@
   "module": "src/index.ts",
   "exports": {
     ".": {
-      "types": "./src/index.ts",
+      "types": "./dist/index.d.ts",
       "import": "./dist/index.js"
     }
   },
   "scripts": {
-    "build": "bun build ./src/index.ts --outdir dist --format esm --target browser --external react --external react-dom --external zod",
-    "typecheck": "tsgo --noEmit",
-    "lint": "oxlint --config ../../.oxlintrc.jsonc .",
+    "build": "bun build ./src/index.ts --outdir dist --format esm --target browser --external react --external react-dom --external zod && tsgo -p tsconfig.build.json",
     "format": "oxfmt --config ../../.oxfmtrc.jsonc --check .",
-    "test": "bun test"
+    "lint": "oxlint --config ../../.oxlintrc.jsonc .",
+    "test": "bun test",
+    "typecheck": "tsgo --noEmit"
   },
   "devDependencies": {
     "@conform-ed/qti-xml": "0.0.13",

package/src/interactions/associate.ts

@@ -1,6 +1,6 @@
 import { z } from "zod";
 
-import { defineInteraction } from "../runtime";
+import { defineInteraction, type InteractionDescriptor } from "../runtime";
 import type { ResponseValue } from "../types";
 
 const associateInteractionNodeSchema = z.object({
@@ -12,7 +12,7 @@ const associateInteractionNodeSchema = z.object({
   maxAssociations: z.number().int().optional(),
 });
 
-export const associateInteraction = defineInteraction({
+export const associateInteraction: InteractionDescriptor<"associateInteraction"> = defineInteraction({
   kind: "associateInteraction",
   schema: associateInteractionNodeSchema,
   scoring: "qti-standard",

package/src/interactions/choice.ts

@@ -1,6 +1,6 @@
 import { z } from "zod";
 
-import { defineInteraction } from "../runtime";
+import { defineInteraction, type InteractionDescriptor } from "../runtime";
 import type { ResponseValue } from "../types";
 
 /** Minimal node shape the runtime/skin rely on; whole-item validation uses the contract. */
@@ -11,7 +11,7 @@ const choiceInteractionNodeSchema = z.object({
   maxChoices: z.number().int().optional(),
 });
 
-export const choiceInteraction = defineInteraction({
+export const choiceInteraction: InteractionDescriptor<"choiceInteraction"> = defineInteraction({
   kind: "choiceInteraction",
   schema: choiceInteractionNodeSchema,
   scoring: "qti-standard",

package/src/interactions/drawing.ts

@@ -1,6 +1,6 @@
 import { z } from "zod";
 
-import { defineInteraction } from "../runtime";
+import { defineInteraction, type InteractionDescriptor } from "../runtime";
 import type { ResponseValue } from "../types";
 
 const drawingInteractionNodeSchema = z.object({
@@ -14,7 +14,7 @@ const drawingInteractionNodeSchema = z.object({
   }),
 });
 
-export const drawingInteraction = defineInteraction({
+export const drawingInteraction: InteractionDescriptor<"drawingInteraction"> = defineInteraction({
   kind: "drawingInteraction",
   schema: drawingInteractionNodeSchema,
   scoring: "qti-standard",

package/src/interactions/end-attempt.ts

@@ -1,6 +1,6 @@
 import { z } from "zod";
 
-import { defineInteraction } from "../runtime";
+import { defineInteraction, type InteractionDescriptor } from "../runtime";
 import type { ResponseValue } from "../types";
 
 const endAttemptInteractionNodeSchema = z.object({
@@ -9,7 +9,7 @@ const endAttemptInteractionNodeSchema = z.object({
   title: z.string().min(1),
 });
 
-export const endAttemptInteraction = defineInteraction({
+export const endAttemptInteraction: InteractionDescriptor<"endAttemptInteraction"> = defineInteraction({
   kind: "endAttemptInteraction",
   schema: endAttemptInteractionNodeSchema,
   scoring: "qti-standard",

package/src/interactions/extended-text.ts

@@ -1,6 +1,6 @@
 import { z } from "zod";
 
-import { defineInteraction } from "../runtime";
+import { defineInteraction, type InteractionDescriptor } from "../runtime";
 import type { ResponseValue } from "../types";
 
 const extendedTextInteractionNodeSchema = z.object({
@@ -11,7 +11,7 @@ const extendedTextInteractionNodeSchema = z.object({
   placeholderText: z.string().optional(),
 });
 
-export const extendedTextInteraction = defineInteraction({
+export const extendedTextInteraction: InteractionDescriptor<"extendedTextInteraction"> = defineInteraction({
   kind: "extendedTextInteraction",
   schema: extendedTextInteractionNodeSchema,
   scoring: "qti-standard",

package/src/interactions/gap-match.ts

@@ -1,6 +1,6 @@
 import { z } from "zod";
 
-import { defineInteraction } from "../runtime";
+import { defineInteraction, type InteractionDescriptor } from "../runtime";
 import type { ResponseValue } from "../types";
 
 const gapMatchInteractionNodeSchema = z.object({
@@ -12,7 +12,7 @@ const gapMatchInteractionNodeSchema = z.object({
   content: z.array(z.looseObject({ kind: z.string().min(1) })).min(1),
 });
 
-export const gapMatchInteraction = defineInteraction({
+export const gapMatchInteraction: InteractionDescriptor<"gapMatchInteraction"> = defineInteraction({
   kind: "gapMatchInteraction",
   schema: gapMatchInteractionNodeSchema,
   scoring: "qti-standard",

package/src/interactions/graphic.ts

@@ -6,7 +6,7 @@
 
 import { z } from "zod";
 
-import { defineInteraction } from "../runtime";
+import { defineInteraction, type InteractionDescriptor } from "../runtime";
 import type { ResponseValue } from "../types";
 
 const objectSchema = z.object({
@@ -26,7 +26,7 @@ function nullInitial(): ResponseValue {
   return null;
 }
 
-export const hotspotInteraction = defineInteraction({
+export const hotspotInteraction: InteractionDescriptor<"hotspotInteraction"> = defineInteraction({
   kind: "hotspotInteraction",
   schema: z.object({
     kind: z.literal("hotspotInteraction"),
@@ -39,7 +39,7 @@ export const hotspotInteraction = defineInteraction({
   initialResponse: nullInitial,
 });
 
-export const graphicOrderInteraction = defineInteraction({
+export const graphicOrderInteraction: InteractionDescriptor<"graphicOrderInteraction"> = defineInteraction({
   kind: "graphicOrderInteraction",
   schema: z.object({
     kind: z.literal("graphicOrderInteraction"),
@@ -51,7 +51,7 @@ export const graphicOrderInteraction = defineInteraction({
   initialResponse: nullInitial,
 });
 
-export const graphicAssociateInteraction = defineInteraction({
+export const graphicAssociateInteraction: InteractionDescriptor<"graphicAssociateInteraction"> = defineInteraction({
   kind: "graphicAssociateInteraction",
   schema: z.object({
     kind: z.literal("graphicAssociateInteraction"),
@@ -64,7 +64,7 @@ export const graphicAssociateInteraction = defineInteraction({
   initialResponse: nullInitial,
 });
 
-export const graphicGapMatchInteraction = defineInteraction({
+export const graphicGapMatchInteraction: InteractionDescriptor<"graphicGapMatchInteraction"> = defineInteraction({
   kind: "graphicGapMatchInteraction",
   schema: z.object({
     kind: z.literal("graphicGapMatchInteraction"),
@@ -77,7 +77,7 @@ export const graphicGapMatchInteraction = defineInteraction({
   initialResponse: nullInitial,
 });
 
-export const selectPointInteraction = defineInteraction({
+export const selectPointInteraction: InteractionDescriptor<"selectPointInteraction"> = defineInteraction({
   kind: "selectPointInteraction",
   schema: z.object({
     kind: z.literal("selectPointInteraction"),
@@ -90,7 +90,7 @@ export const selectPointInteraction = defineInteraction({
 });
 
 /** The common single-interaction stage; multi-interaction stages fail validation. */
-export const positionObjectStage = defineInteraction({
+export const positionObjectStage: InteractionDescriptor<"positionObjectStage"> = defineInteraction({
   kind: "positionObjectStage",
   schema: z.object({
     kind: z.literal("positionObjectStage"),

package/src/interactions/hottext.ts

@@ -1,6 +1,6 @@
 import { z } from "zod";
 
-import { defineInteraction } from "../runtime";
+import { defineInteraction, type InteractionDescriptor } from "../runtime";
 import type { ResponseValue } from "../types";
 
 const hottextInteractionNodeSchema = z.object({
@@ -11,7 +11,7 @@ const hottextInteractionNodeSchema = z.object({
   content: z.array(z.looseObject({ kind: z.string().min(1) })).min(1),
 });
 
-export const hottextInteraction = defineInteraction({
+export const hottextInteraction: InteractionDescriptor<"hottextInteraction"> = defineInteraction({
   kind: "hottextInteraction",
   schema: hottextInteractionNodeSchema,
   scoring: "qti-standard",

package/src/interactions/index.ts

@@ -1,5 +1,4 @@
 import type { InteractionDescriptor } from "../runtime";
-
 import { associateInteraction } from "./associate";
 import { choiceInteraction } from "./choice";
 import { drawingInteraction } from "./drawing";

package/src/interactions/inline-choice.ts

@@ -1,6 +1,6 @@
 import { z } from "zod";
 
-import { defineInteraction } from "../runtime";
+import { defineInteraction, type InteractionDescriptor } from "../runtime";
 import type { ResponseValue } from "../types";
 
 const inlineChoiceInteractionNodeSchema = z.object({
@@ -9,7 +9,7 @@ const inlineChoiceInteractionNodeSchema = z.object({
   inlineChoices: z.array(z.object({ identifier: z.string().min(1) })).min(1),
 });
 
-export const inlineChoiceInteraction = defineInteraction({
+export const inlineChoiceInteraction: InteractionDescriptor<"inlineChoiceInteraction"> = defineInteraction({
   kind: "inlineChoiceInteraction",
   schema: inlineChoiceInteractionNodeSchema,
   scoring: "qti-standard",

package/src/interactions/match.ts

@@ -1,6 +1,6 @@
 import { z } from "zod";
 
-import { defineInteraction } from "../runtime";
+import { defineInteraction, type InteractionDescriptor } from "../runtime";
 import type { ResponseValue } from "../types";
 
 const simpleMatchSetSchema = z.object({
@@ -17,7 +17,7 @@ const matchInteractionNodeSchema = z.object({
   maxAssociations: z.number().int().optional(),
 });
 
-export const matchInteraction = defineInteraction({
+export const matchInteraction: InteractionDescriptor<"matchInteraction"> = defineInteraction({
   kind: "matchInteraction",
   schema: matchInteractionNodeSchema,
   scoring: "qti-standard",

package/src/interactions/media.ts

@@ -1,6 +1,6 @@
 import { z } from "zod";
 
-import { defineInteraction } from "../runtime";
+import { defineInteraction, type InteractionDescriptor } from "../runtime";
 import type { ResponseValue } from "../types";
 
 const mediaInteractionNodeSchema = z.object({
@@ -14,7 +14,7 @@ const mediaInteractionNodeSchema = z.object({
   content: z.array(z.looseObject({ kind: z.string().min(1) })).min(1),
 });
 
-export const mediaInteraction = defineInteraction({
+export const mediaInteraction: InteractionDescriptor<"mediaInteraction"> = defineInteraction({
   kind: "mediaInteraction",
   schema: mediaInteractionNodeSchema,
   scoring: "qti-standard",

package/src/interactions/order.ts

@@ -1,6 +1,6 @@
 import { z } from "zod";
 
-import { defineInteraction } from "../runtime";
+import { defineInteraction, type InteractionDescriptor } from "../runtime";
 import type { ResponseValue } from "../types";
 
 const orderInteractionNodeSchema = z.object({
@@ -11,7 +11,7 @@ const orderInteractionNodeSchema = z.object({
   orientation: z.enum(["horizontal", "vertical"]).optional(),
 });
 
-export const orderInteraction = defineInteraction({
+export const orderInteraction: InteractionDescriptor<"orderInteraction"> = defineInteraction({
   kind: "orderInteraction",
   schema: orderInteractionNodeSchema,
   scoring: "qti-standard",

package/src/interactions/slider.ts

@@ -1,6 +1,6 @@
 import { z } from "zod";
 
-import { defineInteraction } from "../runtime";
+import { defineInteraction, type InteractionDescriptor } from "../runtime";
 import type { ResponseValue } from "../types";
 
 const sliderInteractionNodeSchema = z.object({
@@ -14,7 +14,7 @@ const sliderInteractionNodeSchema = z.object({
   reverse: z.boolean().optional(),
 });
 
-export const sliderInteraction = defineInteraction({
+export const sliderInteraction: InteractionDescriptor<"sliderInteraction"> = defineInteraction({
   kind: "sliderInteraction",
   schema: sliderInteractionNodeSchema,
   scoring: "qti-standard",

package/src/interactions/text-entry.ts

@@ -1,6 +1,6 @@
 import { z } from "zod";
 
-import { defineInteraction } from "../runtime";
+import { defineInteraction, type InteractionDescriptor } from "../runtime";
 import type { ResponseValue } from "../types";
 
 const textEntryInteractionNodeSchema = z.object({
@@ -11,7 +11,7 @@ const textEntryInteractionNodeSchema = z.object({
   patternMask: z.string().optional(),
 });
 
-export const textEntryInteraction = defineInteraction({
+export const textEntryInteraction: InteractionDescriptor<"textEntryInteraction"> = defineInteraction({
   kind: "textEntryInteraction",
   schema: textEntryInteractionNodeSchema,
   scoring: "qti-standard",

package/src/interactions/upload.ts

@@ -1,6 +1,6 @@
 import { z } from "zod";
 
-import { defineInteraction } from "../runtime";
+import { defineInteraction, type InteractionDescriptor } from "../runtime";
 import type { ResponseValue } from "../types";
 
 const uploadInteractionNodeSchema = z.object({
@@ -9,7 +9,7 @@ const uploadInteractionNodeSchema = z.object({
   type: z.string().optional(),
 });
 
-export const uploadInteraction = defineInteraction({
+export const uploadInteraction: InteractionDescriptor<"uploadInteraction"> = defineInteraction({
   kind: "uploadInteraction",
   schema: uploadInteractionNodeSchema,
   scoring: "qti-standard",

package/src/normalized-item.ts

@@ -266,7 +266,7 @@ function convertExpression(expression: unknown): RpExpressionView {
   return {
     ...rest,
     ...(Array.isArray(children) ? { expressions: children.map(convertExpression) } : {}),
-  } as RpExpressionView;
+  } as unknown as RpExpressionView;
 }
 
 function convertBranch(branch: unknown, convertRule: (rule: unknown) => Record<string, unknown>) {
@@ -472,7 +472,9 @@ function convertItemRef(ref: Record<string, unknown>): AssessmentItemRefView {
     ...(typeof ref["required"] === "boolean" ? { required: ref["required"] } : {}),
     ...(ref["preConditions"] !== undefined ? { preConditions: convertPreConditions(ref["preConditions"]) } : {}),
     ...(ref["branchRules"] !== undefined ? { branchRules: convertBranchRules(ref["branchRules"]) } : {}),
-    ...(Array.isArray(ref["weights"]) ? { weights: ref["weights"] as AssessmentItemRefView["weights"] } : {}),
+    ...(Array.isArray(ref["weights"])
+      ? { weights: ref["weights"] as NonNullable<AssessmentItemRefView["weights"]> }
+      : {}),
     ...sessionControlAndTimeLimits(ref),
   };
 }
@@ -493,10 +495,10 @@ function convertSection(section: Record<string, unknown>): AssessmentSectionView
     ...(typeof section["fixed"] === "boolean" ? { fixed: section["fixed"] } : {}),
     ...(typeof section["required"] === "boolean" ? { required: section["required"] } : {}),
     ...(isRecord(section["selection"])
-      ? { selection: section["selection"] as unknown as AssessmentSectionView["selection"] }
+      ? { selection: section["selection"] as unknown as NonNullable<AssessmentSectionView["selection"]> }
       : {}),
     ...(isRecord(section["ordering"])
-      ? { ordering: section["ordering"] as unknown as AssessmentSectionView["ordering"] }
+      ? { ordering: section["ordering"] as unknown as NonNullable<AssessmentSectionView["ordering"]> }
       : {}),
     ...(section["preConditions"] !== undefined
       ? { preConditions: convertPreConditions(section["preConditions"]) }

package/src/pci/interaction.ts

@@ -1,6 +1,6 @@
 import { z } from "zod";
 
-import { defineInteraction } from "../runtime";
+import { defineInteraction, type InteractionDescriptor } from "../runtime";
 import type { ResponseValue } from "../types";
 
 const interactionModuleSchema = z.object({
@@ -32,7 +32,7 @@ const pciNodeSchema = z.object({
  * this descriptor plus a skin from `createPciSkin` (ADR-0003 — the capability gate
  * keeps PCI items undeliverable until then).
  */
-export const portableCustomInteraction = defineInteraction({
+export const portableCustomInteraction: InteractionDescriptor<"portableCustomInteraction"> = defineInteraction({
   kind: "portableCustomInteraction",
   schema: pciNodeSchema,
   scoring: "qti-standard",