@superbuilders/incept-renderer 0.1.0

package/dist/schema-DxNEXGoq.d.ts

@@ -0,0 +1,508 @@
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import { D as DisplayItem, a as DisplayBlock } from './types-MOyn9ktl.js';
+import { z } from 'zod';
+
+/** Theme options for the QTI renderer */
+type QTITheme = "duolingo" | "neobrutalist" | (string & {});
+/** Feedback result for a single response */
+interface ResponseFeedback {
+    isCorrect: boolean;
+    messageHtml?: string;
+}
+/** Correctness info for selected choices */
+interface ChoiceCorrectness {
+    id: string;
+    isCorrect: boolean;
+}
+/**
+ * Props for the QTIRenderer component.
+ *
+ * This is a **controlled, display-only component**. It renders the question
+ * and captures user input, but does NOT include submit buttons or flow logic.
+ * The consuming app is responsible for:
+ * - Providing responses state
+ * - Handling submission
+ * - Providing feedback after validation
+ * - Rendering buttons (Check, Try Again, Continue, etc.)
+ */
+interface QTIRendererProps {
+    /**
+     * The display-safe item to render.
+     * Use `buildDisplayModel()` to create this from a parsed AssessmentItem.
+     */
+    item: DisplayItem;
+    /**
+     * Current user responses, keyed by response identifier.
+     * This is a controlled component - you must manage this state.
+     * @example { "RESPONSE": "A" } or { "RESPONSE": ["A", "C"] }
+     */
+    responses: Record<string, string | string[]>;
+    /**
+     * Callback fired when user selects/changes an answer.
+     * Update your responses state in this callback.
+     */
+    onResponseChange: (responseId: string, value: string | string[]) => void;
+    /**
+     * Theme to apply. Defaults to "duolingo".
+     * Available themes: "duolingo", "neobrutalist", or any custom theme
+     * defined via `[data-qti-theme="your-theme"]` CSS.
+     */
+    theme?: QTITheme;
+    /**
+     * Whether to show feedback states (correct/incorrect styling).
+     * Set to true after validation to display results.
+     */
+    showFeedback?: boolean;
+    /**
+     * Whether to disable all interactions.
+     * Typically set to true when showFeedback is true.
+     */
+    disabled?: boolean;
+    /**
+     * Per-choice correctness for highlighting selected answers.
+     * Keyed by response identifier.
+     */
+    choiceCorrectness?: Record<string, ChoiceCorrectness[]>;
+    /**
+     * Per-response feedback messages to display.
+     * Keyed by response identifier.
+     */
+    responseFeedback?: Record<string, ResponseFeedback>;
+    /**
+     * Overall feedback to display at the end of the question.
+     */
+    overallFeedback?: ResponseFeedback;
+    /**
+     * Additional CSS class for the container.
+     */
+    className?: string;
+}
+interface ContentBlockRendererProps {
+    /** The content block to render */
+    block: DisplayBlock;
+    /** Current user responses */
+    responses?: Record<string, string | string[]>;
+    /** Callback when user selects an answer */
+    onAnswerSelect?: (responseIdentifier: string, value: string | string[]) => void;
+    /** Whether to show feedback */
+    showFeedback?: boolean;
+    /** Whether to disable interactions */
+    disabled?: boolean;
+    /** Selected-only correctness mapping for this render pass */
+    selectedChoicesByResponse?: Record<string, Array<{
+        id: string;
+        isCorrect: boolean;
+    }>>;
+    /** Optional per-response feedback messages from server */
+    perResponseFeedback?: Record<string, {
+        isCorrect: boolean;
+        messageHtml?: string;
+    }>;
+}
+/**
+ * Renders a single content block (stimulus or interaction)
+ */
+declare function ContentBlockRenderer({ block, responses, onAnswerSelect, showFeedback, disabled, selectedChoicesByResponse, perResponseFeedback }: ContentBlockRendererProps): react_jsx_runtime.JSX.Element | null;
+/**
+ * A controlled, display-only component for rendering QTI assessment items.
+ *
+ * **This component does NOT include buttons or submission logic.**
+ * The consuming app is responsible for:
+ * - Managing `responses` state
+ * - Rendering Check/Submit/Try Again buttons
+ * - Calling validation APIs
+ * - Providing feedback data after validation
+ *
+ * @example
+ * ```tsx
+ * const [responses, setResponses] = useState({})
+ * const [feedback, setFeedback] = useState(null)
+ *
+ * <QTIRenderer
+ *   item={displayItem}
+ *   responses={responses}
+ *   onResponseChange={(id, value) => setResponses(prev => ({ ...prev, [id]: value }))}
+ *   theme="neobrutalist"
+ *   showFeedback={!!feedback}
+ *   responseFeedback={feedback?.perResponse}
+ *   overallFeedback={feedback?.overall}
+ *   disabled={!!feedback}
+ * />
+ *
+ * <button onClick={handleCheck}>Check Answer</button>
+ * ```
+ */
+declare function QTIRenderer({ item, responses, onResponseChange, theme, showFeedback, disabled, choiceCorrectness, responseFeedback, overallFeedback, className }: QTIRendererProps): react_jsx_runtime.JSX.Element;
+
+declare const ChoiceInteractionSchema: z.ZodObject<{
+    responseIdentifier: z.ZodString;
+    shuffle: z.ZodBoolean;
+    minChoices: z.ZodNumber;
+    maxChoices: z.ZodNumber;
+    promptHtml: z.ZodString;
+    choices: z.ZodArray<z.ZodObject<{
+        identifier: z.ZodString;
+        contentHtml: z.ZodString;
+        inlineFeedbackHtml: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    type: z.ZodLiteral<"choiceInteraction">;
+}, z.core.$strip>;
+type ChoiceInteraction = z.infer<typeof ChoiceInteractionSchema>;
+declare const AnyInteractionSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    responseIdentifier: z.ZodString;
+    shuffle: z.ZodBoolean;
+    minChoices: z.ZodNumber;
+    maxChoices: z.ZodNumber;
+    promptHtml: z.ZodString;
+    choices: z.ZodArray<z.ZodObject<{
+        identifier: z.ZodString;
+        contentHtml: z.ZodString;
+        inlineFeedbackHtml: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    type: z.ZodLiteral<"choiceInteraction">;
+}, z.core.$strip>, z.ZodObject<{
+    responseIdentifier: z.ZodString;
+    shuffle: z.ZodBoolean;
+    choices: z.ZodArray<z.ZodObject<{
+        identifier: z.ZodString;
+        contentHtml: z.ZodString;
+    }, z.core.$strip>>;
+    type: z.ZodLiteral<"inlineChoiceInteraction">;
+}, z.core.$strip>, z.ZodObject<{
+    responseIdentifier: z.ZodString;
+    expectedLength: z.ZodOptional<z.ZodNumber>;
+    placeholderText: z.ZodOptional<z.ZodString>;
+    patternMask: z.ZodOptional<z.ZodString>;
+    type: z.ZodLiteral<"textEntryInteraction">;
+}, z.core.$strip>, z.ZodObject<{
+    responseIdentifier: z.ZodString;
+    shuffle: z.ZodBoolean;
+    minChoices: z.ZodNumber;
+    maxChoices: z.ZodOptional<z.ZodNumber>;
+    orientation: z.ZodEnum<{
+        vertical: "vertical";
+        horizontal: "horizontal";
+    }>;
+    promptHtml: z.ZodString;
+    choices: z.ZodArray<z.ZodObject<{
+        identifier: z.ZodString;
+        contentHtml: z.ZodString;
+        inlineFeedbackHtml: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    type: z.ZodLiteral<"orderInteraction">;
+}, z.core.$strip>, z.ZodObject<{
+    responseIdentifier: z.ZodString;
+    shuffle: z.ZodBoolean;
+    gapTexts: z.ZodArray<z.ZodObject<{
+        identifier: z.ZodString;
+        contentHtml: z.ZodString;
+        matchMax: z.ZodNumber;
+    }, z.core.$strip>>;
+    gaps: z.ZodArray<z.ZodObject<{
+        identifier: z.ZodString;
+    }, z.core.$strip>>;
+    contentHtml: z.ZodString;
+    type: z.ZodLiteral<"gapMatchInteraction">;
+}, z.core.$strip>, z.ZodObject<{
+    responseIdentifier: z.ZodString;
+    shuffle: z.ZodBoolean;
+    maxAssociations: z.ZodNumber;
+    sourceChoices: z.ZodArray<z.ZodObject<{
+        identifier: z.ZodString;
+        matchMax: z.ZodNumber;
+        contentHtml: z.ZodString;
+    }, z.core.$strip>>;
+    targetChoices: z.ZodArray<z.ZodObject<{
+        identifier: z.ZodString;
+        matchMax: z.ZodNumber;
+        contentHtml: z.ZodString;
+    }, z.core.$strip>>;
+    promptHtml: z.ZodString;
+    type: z.ZodLiteral<"matchInteraction">;
+}, z.core.$strip>], "type">;
+type AnyInteraction = z.infer<typeof AnyInteractionSchema>;
+declare const ResponseDeclarationSchema: z.ZodObject<{
+    identifier: z.ZodString;
+    cardinality: z.ZodEnum<{
+        single: "single";
+        multiple: "multiple";
+        ordered: "ordered";
+    }>;
+    baseType: z.ZodEnum<{
+        string: "string";
+        boolean: "boolean";
+        directedPair: "directedPair";
+        identifier: "identifier";
+        float: "float";
+        integer: "integer";
+        pair: "pair";
+    }>;
+    correctResponse: z.ZodObject<{
+        values: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>;
+    mapping: z.ZodOptional<z.ZodObject<{
+        defaultValue: z.ZodDefault<z.ZodNumber>;
+        lowerBound: z.ZodOptional<z.ZodNumber>;
+        upperBound: z.ZodOptional<z.ZodNumber>;
+        entries: z.ZodArray<z.ZodObject<{
+            key: z.ZodString;
+            value: z.ZodNumber;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+type ResponseDeclaration = z.infer<typeof ResponseDeclarationSchema>;
+declare const FeedbackBlockSchema: z.ZodObject<{
+    outcomeIdentifier: z.ZodString;
+    identifier: z.ZodString;
+    showHide: z.ZodDefault<z.ZodEnum<{
+        show: "show";
+        hide: "hide";
+    }>>;
+    contentHtml: z.ZodString;
+}, z.core.$strip>;
+type FeedbackBlock = z.infer<typeof FeedbackBlockSchema>;
+declare const BaseRuleSchema: z.ZodObject<{
+    type: z.ZodLiteral<"setOutcomeValue">;
+    identifier: z.ZodString;
+    value: z.ZodString;
+}, z.core.$strip>;
+type BaseRule = z.infer<typeof BaseRuleSchema>;
+declare const MatchConditionSchema: z.ZodObject<{
+    type: z.ZodLiteral<"match">;
+    variable: z.ZodString;
+    correct: z.ZodLiteral<true>;
+}, z.core.$strip>;
+type MatchCondition = z.infer<typeof MatchConditionSchema>;
+declare const MatchValueConditionSchema: z.ZodObject<{
+    type: z.ZodLiteral<"matchValue">;
+    variable: z.ZodString;
+    value: z.ZodString;
+}, z.core.$strip>;
+type MatchValueCondition = z.infer<typeof MatchValueConditionSchema>;
+declare const StringMatchConditionSchema: z.ZodObject<{
+    type: z.ZodLiteral<"stringMatch">;
+    variable: z.ZodString;
+    value: z.ZodString;
+    caseSensitive: z.ZodBoolean;
+}, z.core.$strip>;
+type StringMatchCondition = z.infer<typeof StringMatchConditionSchema>;
+declare const MemberConditionSchema: z.ZodObject<{
+    type: z.ZodLiteral<"member">;
+    variable: z.ZodString;
+    value: z.ZodString;
+}, z.core.$strip>;
+type MemberCondition = z.infer<typeof MemberConditionSchema>;
+declare const EqualMapResponseConditionSchema: z.ZodObject<{
+    type: z.ZodLiteral<"equalMapResponse">;
+    variable: z.ZodString;
+    value: z.ZodString;
+}, z.core.$strip>;
+type EqualMapResponseCondition = z.infer<typeof EqualMapResponseConditionSchema>;
+type AndCondition = {
+    type: "and";
+    conditions: AnyCondition[];
+};
+type OrCondition = {
+    type: "or";
+    conditions: AnyCondition[];
+};
+type NotCondition = {
+    type: "not";
+    condition: AnyCondition;
+};
+type AnyCondition = MatchCondition | MatchValueCondition | StringMatchCondition | MemberCondition | AndCondition | OrCondition | NotCondition | EqualMapResponseCondition;
+type ConditionBranch = {
+    condition?: AnyCondition;
+    actions: BaseRule[];
+    nestedRules?: ResponseRule[];
+};
+type ResponseRule = {
+    type: "condition";
+    branches: ConditionBranch[];
+} | {
+    type: "action";
+    action: BaseRule;
+};
+declare const ResponseProcessingSchema: z.ZodObject<{
+    rules: z.ZodArray<z.ZodType<ResponseRule, unknown, z.core.$ZodTypeInternals<ResponseRule, unknown>>>;
+    scoring: z.ZodObject<{
+        responseIdentifier: z.ZodString;
+        correctScore: z.ZodNumber;
+        incorrectScore: z.ZodNumber;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+type ResponseProcessing = z.infer<typeof ResponseProcessingSchema>;
+declare const AssessmentItemSchema: z.ZodObject<{
+    identifier: z.ZodString;
+    title: z.ZodString;
+    timeDependent: z.ZodBoolean;
+    xmlLang: z.ZodString;
+    responseDeclarations: z.ZodArray<z.ZodObject<{
+        identifier: z.ZodString;
+        cardinality: z.ZodEnum<{
+            single: "single";
+            multiple: "multiple";
+            ordered: "ordered";
+        }>;
+        baseType: z.ZodEnum<{
+            string: "string";
+            boolean: "boolean";
+            directedPair: "directedPair";
+            identifier: "identifier";
+            float: "float";
+            integer: "integer";
+            pair: "pair";
+        }>;
+        correctResponse: z.ZodObject<{
+            values: z.ZodArray<z.ZodString>;
+        }, z.core.$strip>;
+        mapping: z.ZodOptional<z.ZodObject<{
+            defaultValue: z.ZodDefault<z.ZodNumber>;
+            lowerBound: z.ZodOptional<z.ZodNumber>;
+            upperBound: z.ZodOptional<z.ZodNumber>;
+            entries: z.ZodArray<z.ZodObject<{
+                key: z.ZodString;
+                value: z.ZodNumber;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    outcomeDeclarations: z.ZodArray<z.ZodObject<{
+        identifier: z.ZodString;
+        cardinality: z.ZodEnum<{
+            single: "single";
+            multiple: "multiple";
+            ordered: "ordered";
+        }>;
+        baseType: z.ZodEnum<{
+            string: "string";
+            boolean: "boolean";
+            directedPair: "directedPair";
+            identifier: "identifier";
+            float: "float";
+            integer: "integer";
+            pair: "pair";
+        }>;
+        defaultValue: z.ZodOptional<z.ZodObject<{
+            value: z.ZodString;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    itemBody: z.ZodObject<{
+        contentBlocks: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+            type: z.ZodLiteral<"stimulus">;
+            html: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"richStimulus">;
+            html: z.ZodString;
+            inlineEmbeds: z.ZodRecord<z.ZodString, z.ZodObject<{
+                responseIdentifier: z.ZodString;
+                shuffle: z.ZodBoolean;
+                choices: z.ZodArray<z.ZodObject<{
+                    identifier: z.ZodString;
+                    contentHtml: z.ZodString;
+                }, z.core.$strip>>;
+                type: z.ZodLiteral<"inlineChoiceInteraction">;
+            }, z.core.$strip>>;
+            textEmbeds: z.ZodRecord<z.ZodString, z.ZodObject<{
+                responseIdentifier: z.ZodString;
+                expectedLength: z.ZodOptional<z.ZodNumber>;
+                placeholderText: z.ZodOptional<z.ZodString>;
+                patternMask: z.ZodOptional<z.ZodString>;
+                type: z.ZodLiteral<"textEntryInteraction">;
+            }, z.core.$strip>>;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"interaction">;
+            interaction: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                responseIdentifier: z.ZodString;
+                shuffle: z.ZodBoolean;
+                minChoices: z.ZodNumber;
+                maxChoices: z.ZodNumber;
+                promptHtml: z.ZodString;
+                choices: z.ZodArray<z.ZodObject<{
+                    identifier: z.ZodString;
+                    contentHtml: z.ZodString;
+                    inlineFeedbackHtml: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>>;
+                type: z.ZodLiteral<"choiceInteraction">;
+            }, z.core.$strip>, z.ZodObject<{
+                responseIdentifier: z.ZodString;
+                shuffle: z.ZodBoolean;
+                choices: z.ZodArray<z.ZodObject<{
+                    identifier: z.ZodString;
+                    contentHtml: z.ZodString;
+                }, z.core.$strip>>;
+                type: z.ZodLiteral<"inlineChoiceInteraction">;
+            }, z.core.$strip>, z.ZodObject<{
+                responseIdentifier: z.ZodString;
+                expectedLength: z.ZodOptional<z.ZodNumber>;
+                placeholderText: z.ZodOptional<z.ZodString>;
+                patternMask: z.ZodOptional<z.ZodString>;
+                type: z.ZodLiteral<"textEntryInteraction">;
+            }, z.core.$strip>, z.ZodObject<{
+                responseIdentifier: z.ZodString;
+                shuffle: z.ZodBoolean;
+                minChoices: z.ZodNumber;
+                maxChoices: z.ZodOptional<z.ZodNumber>;
+                orientation: z.ZodEnum<{
+                    vertical: "vertical";
+                    horizontal: "horizontal";
+                }>;
+                promptHtml: z.ZodString;
+                choices: z.ZodArray<z.ZodObject<{
+                    identifier: z.ZodString;
+                    contentHtml: z.ZodString;
+                    inlineFeedbackHtml: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>>;
+                type: z.ZodLiteral<"orderInteraction">;
+            }, z.core.$strip>, z.ZodObject<{
+                responseIdentifier: z.ZodString;
+                shuffle: z.ZodBoolean;
+                gapTexts: z.ZodArray<z.ZodObject<{
+                    identifier: z.ZodString;
+                    contentHtml: z.ZodString;
+                    matchMax: z.ZodNumber;
+                }, z.core.$strip>>;
+                gaps: z.ZodArray<z.ZodObject<{
+                    identifier: z.ZodString;
+                }, z.core.$strip>>;
+                contentHtml: z.ZodString;
+                type: z.ZodLiteral<"gapMatchInteraction">;
+            }, z.core.$strip>, z.ZodObject<{
+                responseIdentifier: z.ZodString;
+                shuffle: z.ZodBoolean;
+                maxAssociations: z.ZodNumber;
+                sourceChoices: z.ZodArray<z.ZodObject<{
+                    identifier: z.ZodString;
+                    matchMax: z.ZodNumber;
+                    contentHtml: z.ZodString;
+                }, z.core.$strip>>;
+                targetChoices: z.ZodArray<z.ZodObject<{
+                    identifier: z.ZodString;
+                    matchMax: z.ZodNumber;
+                    contentHtml: z.ZodString;
+                }, z.core.$strip>>;
+                promptHtml: z.ZodString;
+                type: z.ZodLiteral<"matchInteraction">;
+            }, z.core.$strip>], "type">;
+        }, z.core.$strip>]>>;
+        feedbackBlocks: z.ZodArray<z.ZodObject<{
+            outcomeIdentifier: z.ZodString;
+            identifier: z.ZodString;
+            showHide: z.ZodDefault<z.ZodEnum<{
+                show: "show";
+                hide: "hide";
+            }>>;
+            contentHtml: z.ZodString;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+    responseProcessing: z.ZodObject<{
+        rules: z.ZodArray<z.ZodType<ResponseRule, unknown, z.core.$ZodTypeInternals<ResponseRule, unknown>>>;
+        scoring: z.ZodObject<{
+            responseIdentifier: z.ZodString;
+            correctScore: z.ZodNumber;
+            incorrectScore: z.ZodNumber;
+        }, z.core.$strip>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+type AssessmentItem = z.infer<typeof AssessmentItemSchema>;
+
+export { type AssessmentItem as A, ContentBlockRenderer as C, type FeedbackBlock as F, QTIRenderer as Q, type ResponseFeedback as R, type QTIRendererProps as a, type QTITheme as b, type ChoiceCorrectness as c, type ContentBlockRendererProps as d, type ChoiceInteraction as e, type AnyInteraction as f, type ResponseDeclaration as g, type ResponseProcessing as h, AssessmentItemSchema as i };

package/dist/types-MOyn9ktl.d.ts

@@ -0,0 +1,102 @@
+type DisplayChoice = {
+    id: string;
+    contentHtml: string;
+    inlineFeedbackHtml?: string;
+};
+type DisplayChoiceInteraction = {
+    type: "choice";
+    responseId: string;
+    cardinality: "single" | "multiple";
+    promptHtml: string;
+    choices: DisplayChoice[];
+    minChoices: number;
+    maxChoices: number;
+};
+type DisplayTextInteraction = {
+    type: "text";
+    responseId: string;
+    expectedLength?: number;
+    placeholder?: string;
+    patternMask?: string;
+};
+type DisplayTextEmbed = {
+    responseId: string;
+    expectedLength?: number;
+    placeholder?: string;
+    patternMask?: string;
+};
+type DisplayOrderInteraction = {
+    type: "order";
+    responseId: string;
+    promptHtml: string;
+    choices: DisplayChoice[];
+    orientation: "vertical" | "horizontal";
+};
+type DisplayGapText = {
+    id: string;
+    contentHtml: string;
+    matchMax: number;
+};
+type DisplayGap = {
+    id: string;
+};
+type DisplayGapMatchInteraction = {
+    type: "gapMatch";
+    responseId: string;
+    gapTexts: DisplayGapText[];
+    gaps: DisplayGap[];
+    contentHtml: string;
+};
+type DisplayAssociableChoice = {
+    id: string;
+    contentHtml: string;
+    matchMax: number;
+};
+type DisplayMatchInteraction = {
+    type: "match";
+    responseId: string;
+    promptHtml: string;
+    maxAssociations: number;
+    sourceChoices: DisplayAssociableChoice[];
+    targetChoices: DisplayAssociableChoice[];
+};
+type DisplayInteraction = DisplayChoiceInteraction | DisplayTextInteraction | DisplayOrderInteraction | DisplayGapMatchInteraction | DisplayMatchInteraction;
+type DisplayInlineEmbed = {
+    responseId: string;
+    shuffle: boolean;
+    choices: Array<Pick<DisplayChoice, "id" | "contentHtml">>;
+};
+type DisplayBlock = {
+    type: "stimulus";
+    html: string;
+} | {
+    type: "richStimulus";
+    html: string;
+    inlineEmbeds: Record<string, DisplayInlineEmbed>;
+    textEmbeds: Record<string, DisplayTextEmbed>;
+} | {
+    type: "interaction";
+    interaction: DisplayInteraction;
+};
+type DisplayItem = {
+    title: string;
+    contentBlocks: DisplayBlock[];
+};
+type FormShape = Record<string, "single" | "multiple" | "ordered" | "directedPair">;
+type ValidateResult = {
+    overallCorrect: boolean;
+    perResponse: Record<string, {
+        isCorrect: boolean;
+        messageHtml?: string;
+    }>;
+    selectedChoicesByResponse: Record<string, Array<{
+        id: string;
+        isCorrect: boolean;
+    }>>;
+    overallFeedback?: {
+        isCorrect: boolean;
+        messageHtml?: string;
+    };
+};
+
+export type { DisplayItem as D, FormShape as F, ValidateResult as V, DisplayBlock as a, DisplayChoice as b, DisplayChoiceInteraction as c, DisplayInlineEmbed as d, DisplayTextEmbed as e, DisplayGap as f };

package/package.json

@@ -0,0 +1,61 @@
+{
+	"name": "@superbuilders/incept-renderer",
+	"version": "0.1.0",
+	"description": "QTI 3.0 Assessment Renderer - Parse, validate, and render QTI XML with customizable themes",
+	"type": "module",
+	"main": "./dist/index.js",
+	"module": "./dist/index.js",
+	"types": "./dist/index.d.ts",
+	"exports": {
+		".": {
+			"types": "./dist/index.d.ts",
+			"import": "./dist/index.js"
+		},
+		"./actions": {
+			"types": "./dist/actions/index.d.ts",
+			"import": "./dist/actions/index.js"
+		},
+		"./components": {
+			"types": "./dist/components/index.d.ts",
+			"import": "./dist/components/index.js"
+		}
+	},
+	"files": ["dist", "README.md"],
+	"scripts": {
+		"build": "tsup",
+		"dev": "tsup --watch",
+		"typecheck": "tsc --noEmit"
+	},
+	"peerDependencies": {
+		"react": "^18 || ^19",
+		"react-dom": "^18 || ^19"
+	},
+	"dependencies": {
+		"@dnd-kit/core": "^6.3.1",
+		"@dnd-kit/sortable": "^10.0.0",
+		"@dnd-kit/utilities": "^3.2.2",
+		"@radix-ui/react-checkbox": "^1.3.3",
+		"@radix-ui/react-label": "^2.1.7",
+		"@radix-ui/react-radio-group": "^1.3.8",
+		"@radix-ui/react-select": "^2.2.6",
+		"@radix-ui/react-separator": "^1.1.7",
+		"class-variance-authority": "^0.7.1",
+		"clsx": "^2.1.1",
+		"fast-xml-parser": "^5.3.0",
+		"lucide-react": "^0.548.0",
+		"tailwind-merge": "^3.3.1",
+		"zod": "^4.1.12"
+	},
+	"devDependencies": {
+		"@types/react": "^19.1.8",
+		"@types/react-dom": "^19.1.6",
+		"tsup": "^8.0.0",
+		"typescript": "^5.8.3"
+	},
+	"keywords": ["qti", "assessment", "quiz", "testing", "education", "renderer", "react"],
+	"license": "MIT",
+	"repository": {
+		"type": "git",
+		"url": "https://github.com/superbuilders/duolingo"
+	}
+}