@quizparts/core 0.0.1

package/dist/actions.d.ts

@@ -0,0 +1,37 @@
+/** Session actions - pure, immutable updates */
+import type { QuizSession } from './state.js';
+/** Select a single choice (multiple_choice). Replaces current selection. */
+export declare const selectChoice: (session: QuizSession, questionIndex: number, choiceId: string) => QuizSession;
+/** Toggle a choice (multi_select). Adds or removes choiceId. */
+export declare const toggleChoice: (session: QuizSession, questionIndex: number, choiceId: string) => QuizSession;
+/** Set text input (text_input). */
+export declare const setTextInput: (session: QuizSession, questionIndex: number, text: string) => QuizSession;
+/** Set match pairs (match_pairs). */
+export declare const setMatchPairs: (session: QuizSession, questionIndex: number, pairs: Array<[string, string]>) => QuizSession;
+/** Set ordered ids (order_items). */
+export declare const setOrderedIds: (session: QuizSession, questionIndex: number, orderedIds: string[]) => QuizSession;
+/** Set sentence order (sentence_builder). */
+export declare const setSentenceOrder: (session: QuizSession, questionIndex: number, sentenceOrder: string[]) => QuizSession;
+/** Submit the current question. Returns new session and whether the answer was correct. */
+export declare const submitAnswer: (session: QuizSession) => {
+    session: QuizSession;
+    correct: boolean;
+};
+/** Move to the next question. Marks current as complete and next as active. */
+export declare const goToNextQuestion: (session: QuizSession) => QuizSession;
+/** Move to the previous question. */
+export declare const goToPreviousQuestion: (session: QuizSession) => QuizSession;
+/** Progress info for the current session */
+export interface Progress {
+    currentIndex: number;
+    total: number;
+    score: number;
+    attemptedCount: number;
+    isComplete: boolean;
+    canGoNext: boolean;
+    canGoPrevious: boolean;
+}
+export declare const getProgress: (session: QuizSession) => Progress;
+/** Reset session to initial state. */
+export declare const resetQuiz: (session: QuizSession) => QuizSession;
+//# sourceMappingURL=actions.d.ts.map

package/dist/actions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"actions.d.ts","sourceRoot":"","sources":["../src/actions.ts"],"names":[],"mappings":"AAAA,gDAAgD;AAEhD,OAAO,KAAK,EAAE,WAAW,EAAiB,MAAM,YAAY,CAAC;AAM7D,4EAA4E;AAC5E,eAAO,MAAM,YAAY,GACvB,SAAS,WAAW,EACpB,eAAe,MAAM,EACrB,UAAU,MAAM,KACf,WAUF,CAAC;AAEF,gEAAgE;AAChE,eAAO,MAAM,YAAY,GACvB,SAAS,WAAW,EACpB,eAAe,MAAM,EACrB,UAAU,MAAM,KACf,WAcF,CAAC;AAEF,mCAAmC;AACnC,eAAO,MAAM,YAAY,GACvB,SAAS,WAAW,EACpB,eAAe,MAAM,EACrB,MAAM,MAAM,KACX,WAUF,CAAC;AAEF,qCAAqC;AACrC,eAAO,MAAM,aAAa,GACxB,SAAS,WAAW,EACpB,eAAe,MAAM,EACrB,OAAO,KAAK,CAAC,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,KAC7B,WAUF,CAAC;AAEF,qCAAqC;AACrC,eAAO,MAAM,aAAa,GACxB,SAAS,WAAW,EACpB,eAAe,MAAM,EACrB,YAAY,MAAM,EAAE,KACnB,WAUF,CAAC;AAEF,6CAA6C;AAC7C,eAAO,MAAM,gBAAgB,GAC3B,SAAS,WAAW,EACpB,eAAe,MAAM,EACrB,eAAe,MAAM,EAAE,KACtB,WAUF,CAAC;AAEF,2FAA2F;AAC3F,eAAO,MAAM,YAAY,GACvB,SAAS,WAAW,KACnB;IAAE,OAAO,EAAE,WAAW,CAAC;IAAC,OAAO,EAAE,OAAO,CAAA;CAqB1C,CAAC;AAEF,+EAA+E;AAC/E,eAAO,MAAM,gBAAgB,GAAI,SAAS,WAAW,KAAG,WAevD,CAAC;AAEF,qCAAqC;AACrC,eAAO,MAAM,oBAAoB,GAAI,SAAS,WAAW,KAAG,WAc3D,CAAC;AAEF,4CAA4C;AAC5C,MAAM,WAAW,QAAQ;IACvB,YAAY,EAAE,MAAM,CAAC;IACrB,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;IACd,cAAc,EAAE,MAAM,CAAC;IACvB,UAAU,EAAE,OAAO,CAAC;IACpB,SAAS,EAAE,OAAO,CAAC;IACnB,aAAa,EAAE,OAAO,CAAC;CACxB;AAED,eAAO,MAAM,WAAW,GAAI,SAAS,WAAW,KAAG,QAalD,CAAC;AAEF,sCAAsC;AACtC,eAAO,MAAM,SAAS,GAAI,SAAS,WAAW,KAAG,WAiBhD,CAAC"}

package/dist/actions.js

@@ -0,0 +1,171 @@
+/** Session actions - pure, immutable updates */
+import { checkCorrectness } from './correctness.js';
+const cloneStates = (states) => states.map((s) => ({ ...s, input: { ...s.input } }));
+/** Select a single choice (multiple_choice). Replaces current selection. */
+export const selectChoice = (session, questionIndex, choiceId) => {
+    if (questionIndex < 0 || questionIndex >= session.questionStates.length) {
+        return session;
+    }
+    const next = cloneStates(session.questionStates);
+    next[questionIndex] = {
+        ...next[questionIndex],
+        input: { ...next[questionIndex].input, selectedChoiceId: choiceId },
+    };
+    return { ...session, questionStates: next };
+};
+/** Toggle a choice (multi_select). Adds or removes choiceId. */
+export const toggleChoice = (session, questionIndex, choiceId) => {
+    if (questionIndex < 0 || questionIndex >= session.questionStates.length) {
+        return session;
+    }
+    const curr = session.questionStates[questionIndex].input.selectedChoiceIds ?? [];
+    const set = new Set(curr);
+    if (set.has(choiceId))
+        set.delete(choiceId);
+    else
+        set.add(choiceId);
+    const next = cloneStates(session.questionStates);
+    next[questionIndex] = {
+        ...next[questionIndex],
+        input: { ...next[questionIndex].input, selectedChoiceIds: [...set] },
+    };
+    return { ...session, questionStates: next };
+};
+/** Set text input (text_input). */
+export const setTextInput = (session, questionIndex, text) => {
+    if (questionIndex < 0 || questionIndex >= session.questionStates.length) {
+        return session;
+    }
+    const next = cloneStates(session.questionStates);
+    next[questionIndex] = {
+        ...next[questionIndex],
+        input: { ...next[questionIndex].input, text },
+    };
+    return { ...session, questionStates: next };
+};
+/** Set match pairs (match_pairs). */
+export const setMatchPairs = (session, questionIndex, pairs) => {
+    if (questionIndex < 0 || questionIndex >= session.questionStates.length) {
+        return session;
+    }
+    const next = cloneStates(session.questionStates);
+    next[questionIndex] = {
+        ...next[questionIndex],
+        input: { ...next[questionIndex].input, matchPairs: pairs },
+    };
+    return { ...session, questionStates: next };
+};
+/** Set ordered ids (order_items). */
+export const setOrderedIds = (session, questionIndex, orderedIds) => {
+    if (questionIndex < 0 || questionIndex >= session.questionStates.length) {
+        return session;
+    }
+    const next = cloneStates(session.questionStates);
+    next[questionIndex] = {
+        ...next[questionIndex],
+        input: { ...next[questionIndex].input, orderedIds },
+    };
+    return { ...session, questionStates: next };
+};
+/** Set sentence order (sentence_builder). */
+export const setSentenceOrder = (session, questionIndex, sentenceOrder) => {
+    if (questionIndex < 0 || questionIndex >= session.questionStates.length) {
+        return session;
+    }
+    const next = cloneStates(session.questionStates);
+    next[questionIndex] = {
+        ...next[questionIndex],
+        input: { ...next[questionIndex].input, sentenceOrder },
+    };
+    return { ...session, questionStates: next };
+};
+/** Submit the current question. Returns new session and whether the answer was correct. */
+export const submitAnswer = (session) => {
+    const idx = session.currentQuestionIndex;
+    if (idx < 0 || idx >= session.quiz.questions.length) {
+        return { session, correct: false };
+    }
+    const question = session.quiz.questions[idx];
+    const input = session.questionStates[idx].input;
+    const correct = checkCorrectness(question, input);
+    const next = cloneStates(session.questionStates);
+    next[idx] = {
+        ...next[idx],
+        status: correct ? 'correct' : 'incorrect',
+        isCorrect: correct,
+    };
+    const newSession = {
+        ...session,
+        questionStates: next,
+        score: session.score + (correct ? 1 : 0),
+        attemptedCount: session.attemptedCount + 1,
+    };
+    return { session: newSession, correct };
+};
+/** Move to the next question. Marks current as complete and next as active. */
+export const goToNextQuestion = (session) => {
+    const idx = session.currentQuestionIndex;
+    const next = cloneStates(session.questionStates);
+    if (idx >= 0 && idx < next.length) {
+        next[idx] = { ...next[idx], status: 'complete' };
+    }
+    const nextIndex = Math.min(idx + 1, session.quiz.questions.length);
+    if (nextIndex < next.length) {
+        next[nextIndex] = { ...next[nextIndex], status: 'active' };
+    }
+    return {
+        ...session,
+        currentQuestionIndex: nextIndex,
+        questionStates: next,
+    };
+};
+/** Move to the previous question. */
+export const goToPreviousQuestion = (session) => {
+    const idx = session.currentQuestionIndex;
+    if (idx <= 0)
+        return session;
+    const next = cloneStates(session.questionStates);
+    if (idx < next.length) {
+        next[idx] = { ...next[idx], status: 'idle' };
+    }
+    const prevIndex = idx - 1;
+    next[prevIndex] = { ...next[prevIndex], status: 'active' };
+    return {
+        ...session,
+        currentQuestionIndex: prevIndex,
+        questionStates: next,
+    };
+};
+export const getProgress = (session) => {
+    const total = session.quiz.questions.length;
+    const current = session.currentQuestionIndex;
+    const isComplete = total === 0 || (current >= total && session.attemptedCount >= total);
+    return {
+        currentIndex: current,
+        total,
+        score: session.score,
+        attemptedCount: session.attemptedCount,
+        isComplete,
+        canGoNext: current < total,
+        canGoPrevious: current > 0,
+    };
+};
+/** Reset session to initial state. */
+export const resetQuiz = (session) => {
+    const s = {
+        ...session,
+        currentQuestionIndex: 0,
+        questionStates: session.quiz.questions.map(() => ({
+            status: 'idle',
+            input: {},
+        })),
+        score: 0,
+        attemptedCount: 0,
+    };
+    if (s.questionStates.length > 0) {
+        const next = cloneStates(s.questionStates);
+        next[0] = { ...next[0], status: 'active' };
+        return { ...s, questionStates: next };
+    }
+    return s;
+};

package/dist/correctness.d.ts

@@ -0,0 +1,6 @@
+/** Correctness checking per question type - no DOM/React */
+import type { QuizQuestion } from '@quizparts/schema';
+import type { QuestionInputState } from './state.js';
+/** Check if the user's input matches the correct answer for the given question */
+export declare const checkCorrectness: (question: QuizQuestion, input: QuestionInputState) => boolean;
+//# sourceMappingURL=correctness.d.ts.map

package/dist/correctness.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"correctness.d.ts","sourceRoot":"","sources":["../src/correctness.ts"],"names":[],"mappings":"AAAA,4DAA4D;AAE5D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AACtD,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAC;AAErD,kFAAkF;AAClF,eAAO,MAAM,gBAAgB,GAC3B,UAAU,YAAY,EACtB,OAAO,kBAAkB,KACxB,OAsCF,CAAC"}

package/dist/correctness.js

@@ -0,0 +1,43 @@
+/** Correctness checking per question type - no DOM/React */
+/** Check if the user's input matches the correct answer for the given question */
+export const checkCorrectness = (question, input) => {
+    switch (question.type) {
+        case 'multiple_choice':
+            return input.selectedChoiceId === question.answer;
+        case 'multi_select': {
+            const selected = input.selectedChoiceIds ?? [];
+            if (selected.length !== question.answer.length)
+                return false;
+            const set = new Set(question.answer);
+            return selected.every((id) => set.has(id));
+        }
+        case 'text_input': {
+            const text = (input.text ?? '').trim();
+            const answer = question.answer.trim();
+            return question.caseInsensitive
+                ? text.toLowerCase() === answer.toLowerCase()
+                : text === answer;
+        }
+        case 'match_pairs': {
+            const pairs = input.matchPairs ?? [];
+            if (pairs.length !== question.answer.length)
+                return false;
+            const normalizedAnswer = new Set(question.answer.map(([a, b]) => `${a}:${b}`));
+            return pairs.every(([l, r]) => normalizedAnswer.has(`${l}:${r}`));
+        }
+        case 'order_items': {
+            const ordered = input.orderedIds ?? [];
+            if (ordered.length !== question.answer.length)
+                return false;
+            return ordered.every((id, i) => id === question.answer[i]);
+        }
+        case 'sentence_builder': {
+            const order = input.sentenceOrder ?? [];
+            if (order.length !== question.answer.length)
+                return false;
+            return order.every((val, i) => val === question.answer[i]);
+        }
+        default:
+            return false;
+    }
+};

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+/** @quizparts/core - Headless quiz engine */
+export { SCHEMA_VERSION } from '@quizparts/schema';
+export declare const CORE_VERSION = "0.0.1";
+export { createQuizSession, createInitialQuestionState, type QuizSession, type QuestionState, type QuestionStatus, type QuestionInputState, } from './state.js';
+export { checkCorrectness } from './correctness.js';
+export { selectChoice, toggleChoice, setTextInput, setMatchPairs, setOrderedIds, setSentenceOrder, submitAnswer, goToNextQuestion, goToPreviousQuestion, getProgress, resetQuiz, type Progress, } from './actions.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,6CAA6C;AAE7C,OAAO,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAEnD,eAAO,MAAM,YAAY,UAAU,CAAC;AAEpC,OAAO,EACL,iBAAiB,EACjB,0BAA0B,EAC1B,KAAK,WAAW,EAChB,KAAK,aAAa,EAClB,KAAK,cAAc,EACnB,KAAK,kBAAkB,GACxB,MAAM,YAAY,CAAC;AAEpB,OAAO,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AAEpD,OAAO,EACL,YAAY,EACZ,YAAY,EACZ,YAAY,EACZ,aAAa,EACb,aAAa,EACb,gBAAgB,EAChB,YAAY,EACZ,gBAAgB,EAChB,oBAAoB,EACpB,WAAW,EACX,SAAS,EACT,KAAK,QAAQ,GACd,MAAM,cAAc,CAAC"}

package/dist/index.js

@@ -0,0 +1,6 @@
+/** @quizparts/core - Headless quiz engine */
+export { SCHEMA_VERSION } from '@quizparts/schema';
+export const CORE_VERSION = '0.0.1';
+export { createQuizSession, createInitialQuestionState, } from './state.js';
+export { checkCorrectness } from './correctness.js';
+export { selectChoice, toggleChoice, setTextInput, setMatchPairs, setOrderedIds, setSentenceOrder, submitAnswer, goToNextQuestion, goToPreviousQuestion, getProgress, resetQuiz, } from './actions.js';

package/dist/index.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=index.test.d.ts.map

package/dist/index.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.test.d.ts","sourceRoot":"","sources":["../src/index.test.ts"],"names":[],"mappings":""}

package/dist/index.test.js

@@ -0,0 +1,207 @@
+import { describe, it, expect } from 'vitest';
+import { parseQuiz } from '@quizparts/schema';
+import { CORE_VERSION, createQuizSession, selectChoice, toggleChoice, setTextInput, setOrderedIds, submitAnswer, goToNextQuestion, goToPreviousQuestion, getProgress, resetQuiz, checkCorrectness, } from './index.js';
+const validQuiz = parseQuiz({
+    id: 'test-quiz',
+    title: 'Test Quiz',
+    questions: [
+        {
+            id: 'q1',
+            type: 'multiple_choice',
+            prompt: 'What is 2+2?',
+            choices: [
+                { id: 'a', text: '3' },
+                { id: 'b', text: '4' },
+                { id: 'c', text: '5' },
+            ],
+            answer: 'b',
+        },
+        {
+            id: 'q2',
+            type: 'text_input',
+            prompt: 'Say "hello"',
+            answer: 'hello',
+        },
+    ],
+});
+describe('@quizparts/core', () => {
+    it('exports CORE_VERSION', () => {
+        expect(CORE_VERSION).toBe('0.0.1');
+    });
+    it('creates session from parsed quiz', () => {
+        if (!validQuiz.success)
+            throw new Error('parse failed');
+        const session = createQuizSession(validQuiz.data);
+        expect(session.quiz.questions).toHaveLength(2);
+        expect(session.currentQuestionIndex).toBe(0);
+        expect(session.score).toBe(0);
+        expect(session.questionStates[0].status).toBe('active');
+        expect(session.questionStates[1].status).toBe('idle');
+    });
+    it('selecting an answer updates state', () => {
+        if (!validQuiz.success)
+            throw new Error('parse failed');
+        const session = createQuizSession(validQuiz.data);
+        const next = selectChoice(session, 0, 'b');
+        expect(next.questionStates[0].input.selectedChoiceId).toBe('b');
+    });
+    it('submitting correct answer returns correct and updates score', () => {
+        if (!validQuiz.success)
+            throw new Error('parse failed');
+        let session = createQuizSession(validQuiz.data);
+        session = selectChoice(session, 0, 'b');
+        const { session: after, correct } = submitAnswer(session);
+        expect(correct).toBe(true);
+        expect(after.score).toBe(1);
+        expect(after.questionStates[0].status).toBe('correct');
+    });
+    it('submitting incorrect answer returns incorrect', () => {
+        if (!validQuiz.success)
+            throw new Error('parse failed');
+        let session = createQuizSession(validQuiz.data);
+        session = selectChoice(session, 0, 'a');
+        const { session: after, correct } = submitAnswer(session);
+        expect(correct).toBe(false);
+        expect(after.score).toBe(0);
+        expect(after.questionStates[0].status).toBe('incorrect');
+    });
+    it('progression: goToNextQuestion advances index and marks current complete', () => {
+        if (!validQuiz.success)
+            throw new Error('parse failed');
+        let session = createQuizSession(validQuiz.data);
+        session = selectChoice(session, 0, 'b');
+        const { session: afterSubmit } = submitAnswer(session);
+        const afterNext = goToNextQuestion(afterSubmit);
+        expect(afterNext.currentQuestionIndex).toBe(1);
+        expect(afterNext.questionStates[0].status).toBe('complete');
+        expect(afterNext.questionStates[1].status).toBe('active');
+    });
+    it('getProgress returns currentIndex, total, score, attemptedCount', () => {
+        if (!validQuiz.success)
+            throw new Error('parse failed');
+        let session = createQuizSession(validQuiz.data);
+        let progress = getProgress(session);
+        expect(progress.currentIndex).toBe(0);
+        expect(progress.total).toBe(2);
+        expect(progress.score).toBe(0);
+        expect(progress.attemptedCount).toBe(0);
+        expect(progress.canGoNext).toBe(true);
+        expect(progress.canGoPrevious).toBe(false);
+        session = selectChoice(session, 0, 'b');
+        const { session: after } = submitAnswer(session);
+        progress = getProgress(after);
+        expect(progress.score).toBe(1);
+        expect(progress.attemptedCount).toBe(1);
+    });
+    it('reset restores initial state', () => {
+        if (!validQuiz.success)
+            throw new Error('parse failed');
+        let session = createQuizSession(validQuiz.data);
+        session = selectChoice(session, 0, 'b');
+        const { session: afterSubmit } = submitAnswer(session);
+        const afterReset = resetQuiz(afterSubmit);
+        expect(afterReset.currentQuestionIndex).toBe(0);
+        expect(afterReset.score).toBe(0);
+        expect(afterReset.attemptedCount).toBe(0);
+        expect(afterReset.questionStates[0].status).toBe('active');
+        expect(afterReset.questionStates[0].input.selectedChoiceId).toBeUndefined();
+    });
+    it('text_input: setTextInput and submit correct answer', () => {
+        if (!validQuiz.success)
+            throw new Error('parse failed');
+        let session = createQuizSession(validQuiz.data);
+        session = goToNextQuestion(session);
+        session = setTextInput(session, 1, 'hello');
+        const { session: after, correct } = submitAnswer(session);
+        expect(correct).toBe(true);
+        expect(after.score).toBe(1);
+    });
+    it('goToPreviousQuestion goes back', () => {
+        if (!validQuiz.success)
+            throw new Error('parse failed');
+        let session = createQuizSession(validQuiz.data);
+        session = goToNextQuestion(session);
+        expect(session.currentQuestionIndex).toBe(1);
+        const back = goToPreviousQuestion(session);
+        expect(back.currentQuestionIndex).toBe(0);
+        expect(back.questionStates[0].status).toBe('active');
+    });
+    it('toggleChoice adds and removes selection for multi_select', () => {
+        const multiQuiz = parseQuiz({
+            id: 'm',
+            title: 'M',
+            questions: [
+                {
+                    id: 'q1',
+                    type: 'multi_select',
+                    prompt: '?',
+                    choices: [
+                        { id: 'a', text: 'A' },
+                        { id: 'b', text: 'B' },
+                    ],
+                    answer: ['a'],
+                },
+            ],
+        });
+        if (!multiQuiz.success)
+            throw new Error('parse failed');
+        let session = createQuizSession(multiQuiz.data);
+        session = toggleChoice(session, 0, 'a');
+        expect(session.questionStates[0].input.selectedChoiceIds).toEqual(['a']);
+        session = toggleChoice(session, 0, 'b');
+        expect(session.questionStates[0].input.selectedChoiceIds).toContain('a');
+        expect(session.questionStates[0].input.selectedChoiceIds).toContain('b');
+        session = toggleChoice(session, 0, 'a');
+        expect(session.questionStates[0].input.selectedChoiceIds).not.toContain('a');
+        expect(session.questionStates[0].input.selectedChoiceIds).toContain('b');
+    });
+    it('checkCorrectness: text_input caseInsensitive', () => {
+        const q = {
+            type: 'text_input',
+            id: 'q1',
+            prompt: '?',
+            answer: 'Hello',
+            caseInsensitive: true,
+        };
+        expect(checkCorrectness(q, { text: 'hello' })).toBe(true);
+        expect(checkCorrectness(q, { text: 'HELLO' })).toBe(true);
+        expect(checkCorrectness(q, { text: 'hi' })).toBe(false);
+    });
+    it('checkCorrectness: multi_select', () => {
+        const q = {
+            type: 'multi_select',
+            id: 'q1',
+            prompt: '?',
+            choices: [{ id: 'a', text: 'A' }, { id: 'b', text: 'B' }],
+            answer: ['a', 'b'],
+        };
+        expect(checkCorrectness(q, { selectedChoiceIds: ['a', 'b'] })).toBe(true);
+        expect(checkCorrectness(q, { selectedChoiceIds: ['b', 'a'] })).toBe(true);
+        expect(checkCorrectness(q, { selectedChoiceIds: ['a'] })).toBe(false);
+        expect(checkCorrectness(q, { selectedChoiceIds: ['a', 'b', 'a'] })).toBe(false);
+    });
+    it('setOrderedIds and submit correct order_items', () => {
+        const orderQuiz = parseQuiz({
+            id: 'o',
+            title: 'O',
+            questions: [
+                {
+                    id: 'q1',
+                    type: 'order_items',
+                    prompt: 'Order',
+                    items: [
+                        { id: '1', text: 'One' },
+                        { id: '2', text: 'Two' },
+                    ],
+                    answer: ['1', '2'],
+                },
+            ],
+        });
+        if (!orderQuiz.success)
+            throw new Error('parse failed');
+        let session = createQuizSession(orderQuiz.data);
+        session = setOrderedIds(session, 0, ['1', '2']);
+        const { correct } = submitAnswer(session);
+        expect(correct).toBe(true);
+    });
+});

package/dist/state.d.ts

@@ -0,0 +1,41 @@
+/** Quiz session state - serializable, no DOM/React */
+import type { Quiz } from '@quizparts/schema';
+/** Lifecycle status for a single question */
+export type QuestionStatus = 'idle' | 'active' | 'answered' | 'correct' | 'incorrect' | 'complete';
+/** User input state per question (by type) */
+export interface QuestionInputState {
+    /** multiple_choice */
+    selectedChoiceId?: string | null;
+    /** multi_select */
+    selectedChoiceIds?: string[];
+    /** text_input */
+    text?: string;
+    /** match_pairs: user's pairing as [left, right][] */
+    matchPairs?: Array<[string, string]>;
+    /** order_items: user's ordered id list */
+    orderedIds?: string[];
+    /** sentence_builder: user's ordered tile values */
+    sentenceOrder?: string[];
+}
+/** State for one question in the session */
+export interface QuestionState {
+    status: QuestionStatus;
+    input: QuestionInputState;
+    /** Set after submit: true if correct */
+    isCorrect?: boolean;
+}
+/** Full quiz session state */
+export interface QuizSession {
+    quiz: Quiz;
+    currentQuestionIndex: number;
+    questionStates: QuestionState[];
+    /** Number of questions answered correctly */
+    score: number;
+    /** Number of questions that have been submitted */
+    attemptedCount: number;
+}
+/** Create initial question state */
+export declare const createInitialQuestionState: () => QuestionState;
+/** Build initial session from a parsed quiz */
+export declare const createQuizSession: (quiz: Quiz) => QuizSession;
+//# sourceMappingURL=state.d.ts.map

package/dist/state.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"state.d.ts","sourceRoot":"","sources":["../src/state.ts"],"names":[],"mappings":"AAAA,sDAAsD;AAEtD,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,mBAAmB,CAAC;AAE9C,6CAA6C;AAC7C,MAAM,MAAM,cAAc,GACtB,MAAM,GACN,QAAQ,GACR,UAAU,GACV,SAAS,GACT,WAAW,GACX,UAAU,CAAC;AAEf,8CAA8C;AAC9C,MAAM,WAAW,kBAAkB;IACjC,sBAAsB;IACtB,gBAAgB,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACjC,mBAAmB;IACnB,iBAAiB,CAAC,EAAE,MAAM,EAAE,CAAC;IAC7B,iBAAiB;IACjB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,qDAAqD;IACrD,UAAU,CAAC,EAAE,KAAK,CAAC,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;IACrC,0CAA0C;IAC1C,UAAU,CAAC,EAAE,MAAM,EAAE,CAAC;IACtB,mDAAmD;IACnD,aAAa,CAAC,EAAE,MAAM,EAAE,CAAC;CAC1B;AAED,4CAA4C;AAC5C,MAAM,WAAW,aAAa;IAC5B,MAAM,EAAE,cAAc,CAAC;IACvB,KAAK,EAAE,kBAAkB,CAAC;IAC1B,wCAAwC;IACxC,SAAS,CAAC,EAAE,OAAO,CAAC;CACrB;AAED,8BAA8B;AAC9B,MAAM,WAAW,WAAW;IAC1B,IAAI,EAAE,IAAI,CAAC;IACX,oBAAoB,EAAE,MAAM,CAAC;IAC7B,cAAc,EAAE,aAAa,EAAE,CAAC;IAChC,6CAA6C;IAC7C,KAAK,EAAE,MAAM,CAAC;IACd,mDAAmD;IACnD,cAAc,EAAE,MAAM,CAAC;CACxB;AAED,oCAAoC;AACpC,eAAO,MAAM,0BAA0B,QAAO,aAG5C,CAAC;AAEH,+CAA+C;AAC/C,eAAO,MAAM,iBAAiB,GAAI,MAAM,IAAI,KAAG,WAc9C,CAAC"}

package/dist/state.js

@@ -0,0 +1,20 @@
+/** Quiz session state - serializable, no DOM/React */
+/** Create initial question state */
+export const createInitialQuestionState = () => ({
+    status: 'idle',
+    input: {},
+});
+/** Build initial session from a parsed quiz */
+export const createQuizSession = (quiz) => {
+    const questionStates = quiz.questions.map(() => createInitialQuestionState());
+    if (questionStates.length > 0) {
+        questionStates[0].status = 'active';
+    }
+    return {
+        quiz,
+        currentQuestionIndex: 0,
+        questionStates,
+        score: 0,
+        attemptedCount: 0,
+    };
+};

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "@quizparts/core",
+  "version": "0.0.1",
+  "description": "Headless quiz engine for QuizParts (session, submit, progress)",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/ovrpro/QuizParts.git"
+  },
+  "homepage": "https://github.com/ovrpro/QuizParts#readme",
+  "bugs": {
+    "url": "https://github.com/ovrpro/QuizParts/issues"
+  },
+  "keywords": ["quiz", "headless", "engine", "learning", "typescript"],
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": ["dist"],
+  "publishConfig": { "access": "public" },
+  "scripts": {
+    "build": "tsc",
+    "lint": "eslint src --ext .ts",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run",
+    "clean": "rm -rf dist"
+  },
+  "dependencies": {
+    "@quizparts/schema": "0.0.1"
+  },
+  "devDependencies": {
+    "typescript": "^5.6.3",
+    "vitest": "^2.1.4"
+  }
+}