learngraph 0.5.0 → 0.7.0

package/dist/types/assessment/bkt.d.ts

@@ -0,0 +1,185 @@
+/**
+ * Bayesian Knowledge Tracing (BKT)
+ *
+ * Implements the classic BKT model for tracking learner mastery.
+ * BKT is a hidden Markov model with two hidden states (mastery/no mastery)
+ * and uses four parameters:
+ * - P(L₀): Prior probability of mastery (pInit)
+ * - P(T): Probability of learning/transition (pLearn)
+ * - P(S): Probability of slip (wrong despite mastery) (pSlip)
+ * - P(G): Probability of guess (correct despite no mastery) (pGuess)
+ *
+ * @see Corbett & Anderson (1994). Knowledge tracing: Modeling the acquisition
+ *      of procedural knowledge. User Modeling and User-Adapted Interaction.
+ *
+ * @packageDocumentation
+ */
+import type { SkillId } from '../types/skill.js';
+import type { BKTParameters, BKTState, BKTConfig, MasteryState } from '../types/index.js';
+/**
+ * Default BKT configuration
+ */
+export declare const BKT_CONFIG_DEFAULTS: Required<BKTConfig>;
+/**
+ * BKT update result
+ */
+export interface BKTUpdateResult {
+    /** Updated mastery probability */
+    pMastery: number;
+    /** Whether mastery threshold is met */
+    isMastered: boolean;
+    /** Probability of the observation given the model */
+    likelihood: number;
+    /** Previous mastery probability (before update) */
+    previousMastery: number;
+}
+/**
+ * BKT prediction result
+ */
+export interface BKTPrediction {
+    /** Probability of correct response */
+    pCorrect: number;
+    /** Expected mastery after correct response */
+    masteryIfCorrect: number;
+    /** Expected mastery after incorrect response */
+    masteryIfIncorrect: number;
+}
+/**
+ * Bayesian Knowledge Tracing Engine
+ *
+ * Tracks learner mastery using the classic BKT model.
+ * Can be used with skill-level or global parameters.
+ *
+ * @example
+ * ```typescript
+ * const bkt = new BKTEngine();
+ *
+ * // Initialize state for a skill
+ * let state = bkt.initializeState('skill-1');
+ *
+ * // Update after correct response
+ * state = bkt.update(state, true).state;
+ * console.log(`Mastery: ${state.pMastery.toFixed(2)}`);
+ *
+ * // Update after incorrect response
+ * state = bkt.update(state, false).state;
+ * ```
+ */
+export declare class BKTEngine {
+    private readonly config;
+    private readonly skillParams;
+    private readonly globalParams;
+    constructor(config?: BKTConfig, globalParams?: BKTParameters);
+    /**
+     * Set parameters for a specific skill
+     */
+    setSkillParameters(skillId: SkillId, params: BKTParameters): void;
+    /**
+     * Get parameters for a skill (falls back to global)
+     */
+    getParameters(skillId?: SkillId): BKTParameters;
+    /**
+     * Initialize BKT state for a skill
+     */
+    initializeState(skillId: SkillId): BKTState;
+    /**
+     * Update BKT state based on an observed response
+     *
+     * Uses Bayes' theorem to update the mastery probability:
+     * - For correct response: P(Lₙ|correct) ∝ P(correct|Lₙ) × P(Lₙ)
+     * - For incorrect response: P(Lₙ|incorrect) ∝ P(incorrect|Lₙ) × P(Lₙ)
+     *
+     * Then applies the learning transition.
+     *
+     * @param state - Current BKT state
+     * @param correct - Whether the response was correct
+     * @param skillId - Optional skill ID for skill-specific parameters
+     * @returns Updated state and result information
+     */
+    update(state: BKTState, correct: boolean, skillId?: SkillId): {
+        state: BKTState;
+        result: BKTUpdateResult;
+    };
+    /**
+     * Update from multiple responses
+     */
+    updateBatch(state: BKTState, responses: boolean[], skillId?: SkillId): {
+        state: BKTState;
+        results: BKTUpdateResult[];
+    };
+    /**
+     * Predict the probability of a correct response
+     */
+    predict(state: BKTState, skillId?: SkillId): BKTPrediction;
+    /**
+     * Estimate number of opportunities until mastery
+     *
+     * Uses a forward simulation assuming consistent correct responses.
+     */
+    estimateOpportunitiesToMastery(state: BKTState, skillId?: SkillId, maxOpportunities?: number): number | null;
+    /**
+     * Check if mastery threshold is met
+     */
+    isMastered(state: BKTState): boolean;
+    /**
+     * Convert BKT state to MasteryState for integration with other systems
+     */
+    toMasteryState(state: BKTState): Partial<MasteryState>;
+    /**
+     * Calculate current streak from history
+     */
+    private calculateStreak;
+}
+/**
+ * Parameter fitting for BKT using grid search
+ *
+ * Finds optimal BKT parameters for a set of response sequences.
+ * Uses grid search with log-likelihood as the objective.
+ */
+export interface BKTFitResult {
+    /** Best parameters found */
+    params: BKTParameters;
+    /** Log-likelihood of the data given the parameters */
+    logLikelihood: number;
+    /** Number of parameter combinations evaluated */
+    evaluations: number;
+}
+/**
+ * Fit BKT parameters to response data
+ *
+ * @param sequences - Array of response sequences (true = correct)
+ * @param gridSize - Number of values to try for each parameter
+ * @returns Best fitting parameters
+ *
+ * @example
+ * ```typescript
+ * const sequences = [
+ *   [false, false, true, true, true],
+ *   [true, false, true, true, true],
+ *   [false, true, true, true, true],
+ * ];
+ *
+ * const result = fitBKTParameters(sequences);
+ * console.log('Best parameters:', result.params);
+ * ```
+ */
+export declare function fitBKTParameters(sequences: boolean[][], gridSize?: number): BKTFitResult;
+/**
+ * Calculate log-likelihood of response sequences given BKT parameters
+ */
+export declare function calculateLogLikelihood(sequences: boolean[][], params: BKTParameters): number;
+/**
+ * Create a BKT engine with default configuration
+ */
+export declare function createBKTEngine(config?: BKTConfig, params?: BKTParameters): BKTEngine;
+/**
+ * Quick mastery estimation using BKT
+ *
+ * Convenience function for simple use cases.
+ *
+ * @param responses - Sequence of correct/incorrect responses
+ * @param params - BKT parameters (optional, uses defaults)
+ * @returns Final mastery probability
+ */
+export declare function estimateMastery(responses: boolean[], params?: BKTParameters): number;
+//# sourceMappingURL=bkt.d.ts.map

package/dist/types/assessment/bkt.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bkt.d.ts","sourceRoot":"","sources":["../../../src/assessment/bkt.ts"],"names":[],"mappings":"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"}

package/dist/types/assessment/index.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Assessment Framework
+ *
+ * This module provides comprehensive assessment capabilities:
+ * - Bayesian Knowledge Tracing (BKT) for skill-level mastery
+ * - Item Response Theory (IRT) for ability estimation
+ * - Unified mastery estimation engine
+ * - Adaptive testing with intelligent item selection
+ *
+ * @packageDocumentation
+ */
+export type { QuestionId, QuestionType, AnswerOption, MatchingPair, Question, QuestionInput, AssessmentId, AssessmentType, SelectionStrategy, TerminationCriteria, Assessment, AssessmentInput, ResponseId, LearnerResponse, AssessmentSession, IRTModel, IRTParameters, IRTAbilityEstimate, IRTConfig, BKTParameters, BKTState, BKTConfig, EvidenceSource, LearningEvidence, EvidenceSummary, ItemSelection, AdaptiveState, AdaptiveConfig, AssessmentResult, DifficultyAdjustment, AssessmentValidation, } from '../types/assessment.js';
+export { createQuestionId, createAssessmentId, createResponseId, BKT_DEFAULTS, } from '../types/assessment.js';
+export { BKTEngine, createBKTEngine, fitBKTParameters, calculateLogLikelihood, estimateMastery, BKT_CONFIG_DEFAULTS, type BKTUpdateResult, type BKTPrediction, type BKTFitResult, } from './bkt.js';
+export { IRTEstimator, createIRTEstimator, calculateProbability, calculateProbabilityDerivative, calculateInformation, calculateTestInformation, calculateStandardError, selectNextItemMFI, abilityToPercentile, abilityToGradeLevel, estimateAbility, IRT_CONFIG_DEFAULTS, type IRTResponse, } from './irt.js';
+export { MasteryEngine, createMasteryEngine, MASTERY_ENGINE_DEFAULTS, type MasteryEngineConfig, type MasteryUpdate, type LearnerMasteryProfile, } from './mastery-engine.js';
+export { AdaptiveEngine, createAdaptiveEngine, createQuestionPool, ADAPTIVE_DEFAULTS, TERMINATION_DEFAULTS, type QuestionPool, type AdaptiveSession, } from './adaptive.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/types/assessment/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/assessment/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAGH,YAAY,EAEV,UAAU,EACV,YAAY,EACZ,YAAY,EACZ,YAAY,EACZ,QAAQ,EACR,aAAa,EAEb,YAAY,EACZ,cAAc,EACd,iBAAiB,EACjB,mBAAmB,EACnB,UAAU,EACV,eAAe,EAEf,UAAU,EACV,eAAe,EACf,iBAAiB,EAEjB,QAAQ,EACR,aAAa,EACb,kBAAkB,EAClB,SAAS,EAET,aAAa,EACb,QAAQ,EACR,SAAS,EAET,cAAc,EACd,gBAAgB,EAChB,eAAe,EAEf,aAAa,EACb,aAAa,EACb,cAAc,EAEd,gBAAgB,EAChB,oBAAoB,EACpB,oBAAoB,GACrB,MAAM,wBAAwB,CAAC;AAChC,OAAO,EACL,gBAAgB,EAChB,kBAAkB,EAClB,gBAAgB,EAChB,YAAY,GACb,MAAM,wBAAwB,CAAC;AAGhC,OAAO,EACL,SAAS,EACT,eAAe,EACf,gBAAgB,EAChB,sBAAsB,EACtB,eAAe,EACf,mBAAmB,EACnB,KAAK,eAAe,EACpB,KAAK,aAAa,EAClB,KAAK,YAAY,GAClB,MAAM,UAAU,CAAC;AAGlB,OAAO,EACL,YAAY,EACZ,kBAAkB,EAClB,oBAAoB,EACpB,8BAA8B,EAC9B,oBAAoB,EACpB,wBAAwB,EACxB,sBAAsB,EACtB,iBAAiB,EACjB,mBAAmB,EACnB,mBAAmB,EACnB,eAAe,EACf,mBAAmB,EACnB,KAAK,WAAW,GACjB,MAAM,UAAU,CAAC;AAGlB,OAAO,EACL,aAAa,EACb,mBAAmB,EACnB,uBAAuB,EACvB,KAAK,mBAAmB,EACxB,KAAK,aAAa,EAClB,KAAK,qBAAqB,GAC3B,MAAM,qBAAqB,CAAC;AAG7B,OAAO,EACL,cAAc,EACd,oBAAoB,EACpB,kBAAkB,EAClB,iBAAiB,EACjB,oBAAoB,EACpB,KAAK,YAAY,EACjB,KAAK,eAAe,GACrB,MAAM,eAAe,CAAC"}

package/dist/types/assessment/irt.d.ts

@@ -0,0 +1,159 @@
+/**
+ * Item Response Theory (IRT)
+ *
+ * Implements the 1PL (Rasch), 2PL, and 3PL IRT models for:
+ * - Calculating probability of correct response
+ * - Estimating learner ability (theta)
+ * - Calculating item information
+ * - Adaptive item selection
+ *
+ * @see Lord, F.M. (1980). Applications of item response theory to practical testing problems.
+ *
+ * @packageDocumentation
+ */
+import type { IRTParameters, IRTAbilityEstimate, IRTConfig, QuestionId } from '../types/index.js';
+/**
+ * Default IRT configuration
+ */
+export declare const IRT_CONFIG_DEFAULTS: Required<IRTConfig>;
+/**
+ * IRT response data for estimation
+ */
+export interface IRTResponse {
+    /** Question ID */
+    questionId: QuestionId;
+    /** Item parameters */
+    params: IRTParameters;
+    /** Whether response was correct */
+    correct: boolean;
+}
+/**
+ * Calculate probability of correct response using IRT model
+ *
+ * 1PL (Rasch): P(θ) = 1 / (1 + exp(-(θ - b)))
+ * 2PL: P(θ) = 1 / (1 + exp(-a(θ - b)))
+ * 3PL: P(θ) = c + (1 - c) / (1 + exp(-a(θ - b)))
+ *
+ * @param theta - Ability parameter
+ * @param params - Item parameters
+ * @returns Probability of correct response (0-1)
+ */
+export declare function calculateProbability(theta: number, params: IRTParameters): number;
+/**
+ * Calculate the first derivative of P with respect to theta
+ * Used in ability estimation
+ */
+export declare function calculateProbabilityDerivative(theta: number, params: IRTParameters): number;
+/**
+ * Calculate Fisher Information for an item at a given ability
+ *
+ * Information represents how precisely the item measures ability at theta.
+ * Higher information = more useful for measuring that ability level.
+ *
+ * I(θ) = [P'(θ)]² / [P(θ)(1-P(θ))]
+ */
+export declare function calculateInformation(theta: number, params: IRTParameters): number;
+/**
+ * Calculate test information (sum of item information)
+ */
+export declare function calculateTestInformation(theta: number, items: IRTParameters[]): number;
+/**
+ * Calculate standard error of ability estimate
+ * SE(θ) = 1 / √I(θ)
+ */
+export declare function calculateStandardError(theta: number, items: IRTParameters[]): number;
+/**
+ * IRT Ability Estimator
+ *
+ * Estimates learner ability (theta) from response patterns using
+ * Maximum Likelihood Estimation (MLE) or Expected A Posteriori (EAP).
+ */
+export declare class IRTEstimator {
+    private readonly config;
+    constructor(config?: IRTConfig);
+    /**
+     * Estimate ability using Maximum Likelihood Estimation (MLE)
+     *
+     * Uses Newton-Raphson iteration to find the theta that maximizes
+     * the likelihood of the observed response pattern.
+     */
+    estimateMLE(responses: IRTResponse[]): IRTAbilityEstimate;
+    /**
+     * Estimate ability using Expected A Posteriori (EAP)
+     *
+     * Uses numerical integration with a prior distribution.
+     * More stable than MLE, especially with few responses.
+     */
+    estimateEAP(responses: IRTResponse[]): IRTAbilityEstimate;
+    /**
+     * Estimate ability using Maximum A Posteriori (MAP)
+     *
+     * Like MLE but includes prior distribution.
+     */
+    estimateMAP(responses: IRTResponse[]): IRTAbilityEstimate;
+    /**
+     * Auto-select best estimation method based on response count
+     */
+    estimate(responses: IRTResponse[]): IRTAbilityEstimate;
+    /**
+     * Calculate log-likelihood derivatives for Newton-Raphson
+     */
+    private calculateDerivatives;
+    /**
+     * Calculate likelihood of response pattern
+     */
+    private calculateLikelihood;
+    /**
+     * Normal PDF for prior
+     */
+    private normalPDF;
+    /**
+     * Build ability estimate result
+     */
+    private buildEstimate;
+    /**
+     * Default estimate when no responses
+     */
+    private defaultEstimate;
+    /**
+     * Handle extreme response patterns
+     */
+    private extremeEstimate;
+}
+/**
+ * Select next item for adaptive testing using Maximum Fisher Information
+ *
+ * Selects the item that provides the most information at the current ability estimate.
+ */
+export declare function selectNextItemMFI(currentTheta: number, availableItems: {
+    id: QuestionId;
+    params: IRTParameters;
+}[], administeredIds: Set<QuestionId>): {
+    id: QuestionId;
+    params: IRTParameters;
+    information: number;
+} | null;
+/**
+ * Convert ability (theta) to percentile
+ *
+ * Assumes standard normal distribution of ability.
+ */
+export declare function abilityToPercentile(theta: number): number;
+/**
+ * Convert ability to grade-level equivalent (rough approximation)
+ *
+ * Maps theta to approximate grade level (K-12 scale).
+ */
+export declare function abilityToGradeLevel(theta: number): number;
+/**
+ * Create an IRT estimator
+ */
+export declare function createIRTEstimator(config?: IRTConfig): IRTEstimator;
+/**
+ * Quick ability estimation using EAP
+ */
+export declare function estimateAbility(responses: {
+    params: IRTParameters;
+    correct: boolean;
+}[], config?: IRTConfig): number;
+//# sourceMappingURL=irt.d.ts.map

package/dist/types/assessment/irt.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"irt.d.ts","sourceRoot":"","sources":["../../../src/assessment/irt.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,KAAK,EACV,aAAa,EACb,kBAAkB,EAClB,SAAS,EACT,UAAU,EACX,MAAM,mBAAmB,CAAC;AAE3B;;GAEG;AACH,eAAO,MAAM,mBAAmB,EAAE,QAAQ,CAAC,SAAS,CAKnD,CAAC;AAEF;;GAEG;AACH,MAAM,WAAW,WAAW;IAC1B,kBAAkB;IAClB,UAAU,EAAE,UAAU,CAAC;IACvB,sBAAsB;IACtB,MAAM,EAAE,aAAa,CAAC;IACtB,mCAAmC;IACnC,OAAO,EAAE,OAAO,CAAC;CAClB;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,oBAAoB,CAClC,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,aAAa,GACpB,MAAM,CAmBR;AAED;;;GAGG;AACH,wBAAgB,8BAA8B,CAC5C,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,aAAa,GACpB,MAAM,CAmBR;AAED;;;;;;;GAOG;AACH,wBAAgB,oBAAoB,CAClC,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,aAAa,GACpB,MAAM,CAWR;AAED;;GAEG;AACH,wBAAgB,wBAAwB,CACtC,KAAK,EAAE,MAAM,EACb,KAAK,EAAE,aAAa,EAAE,GACrB,MAAM,CAER;AAED;;;GAGG;AACH,wBAAgB,sBAAsB,CACpC,KAAK,EAAE,MAAM,EACb,KAAK,EAAE,aAAa,EAAE,GACrB,MAAM,CAMR;AAED;;;;;GAKG;AACH,qBAAa,YAAY;IACvB,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAsB;gBAEjC,MAAM,GAAE,SAAc;IAIlC;;;;;OAKG;IACH,WAAW,CAAC,SAAS,EAAE,WAAW,EAAE,GAAG,kBAAkB;IAgDzD;;;;;OAKG;IACH,WAAW,CAAC,SAAS,EAAE,WAAW,EAAE,GAAG,kBAAkB;IAgEzD;;;;OAIG;IACH,WAAW,CAAC,SAAS,EAAE,WAAW,EAAE,GAAG,kBAAkB;IA4CzD;;OAEG;IACH,QAAQ,CAAC,SAAS,EAAE,WAAW,EAAE,GAAG,kBAAkB;IAOtD;;OAEG;IACH,OAAO,CAAC,oBAAoB;IA0B5B;;OAEG;IACH,OAAO,CAAC,mBAAmB;IAW3B;;OAEG;IACH,OAAO,CAAC,SAAS;IAKjB;;OAEG;IACH,OAAO,CAAC,aAAa;IAoBrB;;OAEG;IACH,OAAO,CAAC,eAAe;IAavB;;OAEG;IACH,OAAO,CAAC,eAAe;CAmBxB;AAED;;;;GAIG;AACH,wBAAgB,iBAAiB,CAC/B,YAAY,EAAE,MAAM,EACpB,cAAc,EAAE;IAAE,EAAE,EAAE,UAAU,CAAC;IAAC,MAAM,EAAE,aAAa,CAAA;CAAE,EAAE,EAC3D,eAAe,EAAE,GAAG,CAAC,UAAU,CAAC,GAC/B;IAAE,EAAE,EAAE,UAAU,CAAC;IAAC,MAAM,EAAE,aAAa,CAAC;IAAC,WAAW,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CAiBvE;AAED;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAWzD;AAED;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAIzD;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,CAAC,EAAE,SAAS,GAAG,YAAY,CAEnE;AAED;;GAEG;AACH,wBAAgB,eAAe,CAC7B,SAAS,EAAE;IAAE,MAAM,EAAE,aAAa,CAAC;IAAC,OAAO,EAAE,OAAO,CAAA;CAAE,EAAE,EACxD,MAAM,CAAC,EAAE,SAAS,GACjB,MAAM,CASR"}

package/dist/types/assessment/mastery-engine.d.ts

@@ -0,0 +1,178 @@
+/**
+ * Mastery Estimation Engine
+ *
+ * Unified engine for estimating and tracking learner mastery.
+ * Combines multiple evidence sources:
+ * - Bayesian Knowledge Tracing (BKT) for skill-level mastery
+ * - Item Response Theory (IRT) for ability estimation
+ * - Response patterns for confidence calibration
+ * - Time-based decay for forgetting
+ *
+ * @packageDocumentation
+ */
+import type { SkillId } from '../types/skill.js';
+import type { BKTParameters, BKTState, IRTParameters, LearningEvidence, EvidenceSource, EvidenceSummary, MasteryState, ResponseRecord } from '../types/index.js';
+/**
+ * Mastery engine configuration
+ */
+export interface MasteryEngineConfig {
+    /** Use BKT for skill-level tracking */
+    useBKT?: boolean;
+    /** Use IRT for ability estimation */
+    useIRT?: boolean;
+    /** Apply time-based forgetting */
+    applyForgetting?: boolean;
+    /** Forgetting rate (per day) */
+    forgettingRate?: number;
+    /** Mastery threshold */
+    masteryThreshold?: number;
+    /** BKT parameters */
+    bktParams?: BKTParameters;
+    /** Weights for evidence sources */
+    evidenceWeights?: Partial<Record<EvidenceSource, number>>;
+}
+/**
+ * Default engine configuration
+ */
+export declare const MASTERY_ENGINE_DEFAULTS: Required<MasteryEngineConfig>;
+/**
+ * Mastery update event
+ */
+export interface MasteryUpdate {
+    /** Skill ID */
+    skillId: SkillId;
+    /** Previous mastery level */
+    previousMastery: number;
+    /** New mastery level */
+    newMastery: number;
+    /** Change in mastery */
+    delta: number;
+    /** Update reason */
+    reason: 'response' | 'evidence' | 'decay' | 'reset';
+    /** Timestamp */
+    timestamp: Date;
+}
+/**
+ * Learner profile for the mastery engine
+ */
+export interface LearnerMasteryProfile {
+    /** Learner identifier */
+    learnerId: string;
+    /** BKT states per skill */
+    bktStates: Map<SkillId, BKTState>;
+    /** Mastery levels per skill */
+    masteryLevels: Map<SkillId, number>;
+    /** IRT ability estimate */
+    abilityEstimate?: number;
+    /** Evidence by skill */
+    evidence: Map<SkillId, LearningEvidence[]>;
+    /** Response history */
+    responseHistory: ResponseRecord[];
+    /** Last activity timestamp */
+    lastActivity: Date;
+    /** Update history */
+    updateHistory: MasteryUpdate[];
+}
+/**
+ * Mastery Estimation Engine
+ *
+ * Provides a unified interface for tracking learner mastery across skills.
+ *
+ * @example
+ * ```typescript
+ * const engine = new MasteryEngine();
+ *
+ * // Initialize a learner profile
+ * const profile = engine.createProfile('learner-1');
+ *
+ * // Record a response
+ * const updated = engine.recordResponse(profile, 'skill-1', true);
+ * console.log(`Mastery: ${engine.getMastery(updated, 'skill-1')}`);
+ *
+ * // Check if skill is mastered
+ * console.log(`Mastered: ${engine.isMastered(updated, 'skill-1')}`);
+ * ```
+ */
+export declare class MasteryEngine {
+    private readonly config;
+    private readonly bktEngine;
+    private readonly irtEstimator;
+    constructor(config?: MasteryEngineConfig);
+    /**
+     * Create a new learner profile
+     */
+    createProfile(learnerId: string): LearnerMasteryProfile;
+    /**
+     * Get or initialize BKT state for a skill
+     */
+    private getOrCreateBKTState;
+    /**
+     * Record a learner response and update mastery
+     */
+    recordResponse(profile: LearnerMasteryProfile, skillId: SkillId, correct: boolean, responseTime?: number, itemParams?: IRTParameters): LearnerMasteryProfile;
+    /**
+     * Record multiple responses at once
+     */
+    recordResponses(profile: LearnerMasteryProfile, responses: Array<{
+        skillId: SkillId;
+        correct: boolean;
+        responseTime?: number;
+    }>): LearnerMasteryProfile;
+    /**
+     * Add learning evidence
+     */
+    addEvidence(profile: LearnerMasteryProfile, evidence: LearningEvidence): LearnerMasteryProfile;
+    /**
+     * Get current mastery level for a skill
+     */
+    getMastery(profile: LearnerMasteryProfile, skillId: SkillId): number;
+    /**
+     * Get mastery for multiple skills
+     */
+    getMasteryMap(profile: LearnerMasteryProfile, skillIds: SkillId[]): Map<SkillId, number>;
+    /**
+     * Check if a skill is mastered
+     */
+    isMastered(profile: LearnerMasteryProfile, skillId: SkillId): boolean;
+    /**
+     * Get skills that are mastered
+     */
+    getMasteredSkills(profile: LearnerMasteryProfile): SkillId[];
+    /**
+     * Calculate mastery combining all evidence sources
+     */
+    private calculateMastery;
+    /**
+     * Apply time-based forgetting
+     */
+    private applyForgetting;
+    /**
+     * Update IRT ability estimate
+     */
+    private updateAbility;
+    /**
+     * Reset mastery for a skill
+     */
+    resetMastery(profile: LearnerMasteryProfile, skillId: SkillId): LearnerMasteryProfile;
+    /**
+     * Get evidence summary for a skill
+     */
+    getEvidenceSummary(profile: LearnerMasteryProfile, skillId: SkillId): EvidenceSummary | null;
+    /**
+     * Predict probability of correct response
+     */
+    predictCorrect(profile: LearnerMasteryProfile, skillId: SkillId): number;
+    /**
+     * Estimate opportunities until mastery
+     */
+    estimateOpportunitiesToMastery(profile: LearnerMasteryProfile, skillId: SkillId): number | null;
+    /**
+     * Convert profile to MasteryState map for integration
+     */
+    toMasteryStates(profile: LearnerMasteryProfile, skillIds?: SkillId[]): Map<SkillId, MasteryState>;
+}
+/**
+ * Create a mastery engine with default configuration
+ */
+export declare function createMasteryEngine(config?: MasteryEngineConfig): MasteryEngine;
+//# sourceMappingURL=mastery-engine.d.ts.map

package/dist/types/assessment/mastery-engine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mastery-engine.d.ts","sourceRoot":"","sources":["../../../src/assessment/mastery-engine.ts"],"names":[],"mappings":"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"}

package/dist/types/components/LearningPathView.d.ts

@@ -0,0 +1,40 @@
+/**
+ * LearningPathView Component
+ *
+ * Displays a learning path with progress tracking.
+ *
+ * @packageDocumentation
+ */
+import { type FC } from 'react';
+import type { LearningPathViewProps } from './types.js';
+/**
+ * LearningPathView Component
+ *
+ * Displays a learning path with progress tracking and step navigation.
+ *
+ * @example
+ * ```tsx
+ * import { LearningPathView } from 'learngraph/components';
+ *
+ * function PathToAlgebra() {
+ *   const { steps } = useLearningPath({
+ *     targetSkillId: 'algebra-101',
+ *   });
+ *
+ *   return (
+ *     <LearningPathView
+ *       steps={steps}
+ *       targetSkillName="Algebra Basics"
+ *       viewMode="timeline"
+ *       onStepClick={(step) => console.log('Selected:', step.skill.name)}
+ *       onStartStep={(step) => startLesson(step.skill.id)}
+ *       showProgress
+ *       showTimeEstimates
+ *     />
+ *   );
+ * }
+ * ```
+ */
+export declare const LearningPathView: FC<LearningPathViewProps>;
+export default LearningPathView;
+//# sourceMappingURL=LearningPathView.d.ts.map

package/dist/types/components/LearningPathView.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"LearningPathView.d.ts","sourceRoot":"","sources":["../../../src/components/LearningPathView.tsx"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAE,KAAK,EAAE,EAA+B,MAAM,OAAO,CAAC;AAC7D,OAAO,KAAK,EAAE,qBAAqB,EAAY,MAAM,YAAY,CAAC;AA+UlE;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,eAAO,MAAM,gBAAgB,EAAE,EAAE,CAAC,qBAAqB,CAgMtD,CAAC;AAEF,eAAe,gBAAgB,CAAC"}

package/dist/types/components/ProgressDashboard.d.ts

@@ -0,0 +1,49 @@
+/**
+ * ProgressDashboard Component
+ *
+ * Dashboard showing learning progress and statistics.
+ *
+ * @packageDocumentation
+ */
+import { type FC } from 'react';
+import type { ProgressDashboardProps } from './types.js';
+/**
+ * ProgressDashboard Component
+ *
+ * Comprehensive dashboard for tracking learning progress.
+ *
+ * @example
+ * ```tsx
+ * import { ProgressDashboard } from 'learngraph/components';
+ *
+ * function Dashboard() {
+ *   return (
+ *     <ProgressDashboard
+ *       stats={{
+ *         totalSkills: 50,
+ *         masteredSkills: 15,
+ *         inProgressSkills: 5,
+ *         availableSkills: 10,
+ *         totalLearningTime: 480,
+ *         averageMastery: 0.72,
+ *         streakDays: 7,
+ *         weeklyProgress: 3,
+ *       }}
+ *       bloomProgress={[
+ *         { level: 'remember', total: 10, mastered: 8, percentage: 80 },
+ *         { level: 'understand', total: 12, mastered: 5, percentage: 42 },
+ *         // ...
+ *       ]}
+ *       recentActivity={activities}
+ *       dueForReview={reviewSkills}
+ *       recommendations={recommendedSkills}
+ *       showDetailedStats
+ *       showActivityFeed
+ *     />
+ *   );
+ * }
+ * ```
+ */
+export declare const ProgressDashboard: FC<ProgressDashboardProps>;
+export default ProgressDashboard;
+//# sourceMappingURL=ProgressDashboard.d.ts.map

package/dist/types/components/ProgressDashboard.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ProgressDashboard.d.ts","sourceRoot":"","sources":["../../../src/components/ProgressDashboard.tsx"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAc,EAAE,KAAK,EAAE,EAA+B,MAAM,OAAO,CAAC;AAEpE,OAAO,KAAK,EACV,sBAAsB,EAIvB,MAAM,YAAY,CAAC;AA8bpB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,eAAO,MAAM,iBAAiB,EAAE,EAAE,CAAC,sBAAsB,CAuHxD,CAAC;AAEF,eAAe,iBAAiB,CAAC"}