@lssm/module.learning-journey 0.0.0-canary-20251217062943 → 0.0.0-canary-20251217072406

package/dist/engines/srs.js

@@ -1 +1,219 @@
-const e={learningSteps:[1,10],graduatingInterval:1,easyInterval:4,relearningSteps:[10],minEaseFactor:1.3,maxInterval:365,intervalModifier:1,newIntervalModifier:.5,hardIntervalModifier:1.2,easyBonus:1.3};var t=class{config;constructor(t={}){this.config={...e,...t}}calculateNextReview(e,t,n=new Date){return!e.isGraduated&&!e.isRelearning?this.handleLearningCard(e,t,n):e.isRelearning?this.handleRelearningCard(e,t,n):this.handleReviewCard(e,t,n)}handleLearningCard(e,t,n){let r=this.config.learningSteps,i=e.learningStep,a=!1,o=0,s;switch(t){case`AGAIN`:i=0,o=r[0]??1,s=this.addMinutes(n,o);break;case`HARD`:o=r[i]??r[0]??1,s=this.addMinutes(n,o);break;case`GOOD`:i++,i>=r.length?(a=!0,o=this.config.graduatingInterval,s=this.addDays(n,o)):(o=r[i]??10,s=this.addMinutes(n,o));break;case`EASY`:a=!0,o=this.config.easyInterval,s=this.addDays(n,o);break}return{interval:a?o:0,easeFactor:e.easeFactor,repetitions:a?1:0,nextReviewAt:s,learningStep:i,isGraduated:a,isRelearning:!1,lapses:e.lapses}}handleRelearningCard(e,t,n){let r=this.config.relearningSteps,i=e.learningStep,a=!0,o=0,s;switch(t){case`AGAIN`:i=0,o=r[0]??10,s=this.addMinutes(n,o);break;case`HARD`:o=r[i]??r[0]??10,s=this.addMinutes(n,o);break;case`GOOD`:i++,i>=r.length?(a=!1,o=Math.max(1,Math.floor(e.interval*this.config.newIntervalModifier)),s=this.addDays(n,o)):(o=r[i]??10,s=this.addMinutes(n,o));break;case`EASY`:a=!1,o=Math.max(1,Math.floor(e.interval*this.config.newIntervalModifier*1.5)),s=this.addDays(n,o);break}return{interval:a?e.interval:o,easeFactor:e.easeFactor,repetitions:a?e.repetitions:e.repetitions+1,nextReviewAt:s,learningStep:i,isGraduated:!0,isRelearning:a,lapses:e.lapses}}handleReviewCard(e,t,n){let r,i=e.easeFactor,a=e.repetitions,o=!1,s=0,c=e.lapses;switch(t){case`AGAIN`:c++,o=!0,s=0,i=Math.max(this.config.minEaseFactor,i-.2),r=e.interval;let t=this.config.relearningSteps[0]??10;return{interval:r,easeFactor:i,repetitions:a,nextReviewAt:this.addMinutes(n,t),learningStep:s,isGraduated:!0,isRelearning:!0,lapses:c};case`HARD`:i=Math.max(this.config.minEaseFactor,i-.15),r=Math.max(e.interval+1,e.interval*this.config.hardIntervalModifier);break;case`GOOD`:r=e.interval*i*this.config.intervalModifier,a++;break;case`EASY`:i+=.15,r=e.interval*i*this.config.easyBonus*this.config.intervalModifier,a++;break}return r=Math.min(Math.round(r),this.config.maxInterval),r=Math.max(1,r),{interval:r,easeFactor:i,repetitions:a,nextReviewAt:this.addDays(n,r),learningStep:s,isGraduated:!0,isRelearning:o,lapses:c}}getInitialState(){return{interval:0,easeFactor:2.5,repetitions:0,learningStep:0,isGraduated:!1,isRelearning:!1,lapses:0}}isDue(e,t=new Date){return e<=t}getOverdueDays(e,t=new Date){let n=t.getTime()-e.getTime();return Math.floor(n/(1e3*60*60*24))}addMinutes(e,t){return new Date(e.getTime()+t*60*1e3)}addDays(e,t){return new Date(e.getTime()+t*24*60*60*1e3)}};const n=new t;export{e as DEFAULT_SRS_CONFIG,t as SRSEngine,n as srsEngine};
+//#region src/engines/srs.ts
+const DEFAULT_SRS_CONFIG = {
+	learningSteps: [1, 10],
+	graduatingInterval: 1,
+	easyInterval: 4,
+	relearningSteps: [10],
+	minEaseFactor: 1.3,
+	maxInterval: 365,
+	intervalModifier: 1,
+	newIntervalModifier: .5,
+	hardIntervalModifier: 1.2,
+	easyBonus: 1.3
+};
+var SRSEngine = class {
+	config;
+	constructor(config = {}) {
+		this.config = {
+			...DEFAULT_SRS_CONFIG,
+			...config
+		};
+	}
+	/**
+	* Calculate the next review state based on rating.
+	*/
+	calculateNextReview(state, rating, now = /* @__PURE__ */ new Date()) {
+		if (!state.isGraduated && !state.isRelearning) return this.handleLearningCard(state, rating, now);
+		if (state.isRelearning) return this.handleRelearningCard(state, rating, now);
+		return this.handleReviewCard(state, rating, now);
+	}
+	/**
+	* Handle learning phase (new cards).
+	*/
+	handleLearningCard(state, rating, now) {
+		const steps = this.config.learningSteps;
+		let newStep = state.learningStep;
+		let isGraduated = false;
+		let interval = 0;
+		let nextReviewAt;
+		switch (rating) {
+			case "AGAIN":
+				newStep = 0;
+				interval = steps[0] ?? 1;
+				nextReviewAt = this.addMinutes(now, interval);
+				break;
+			case "HARD":
+				interval = steps[newStep] ?? steps[0] ?? 1;
+				nextReviewAt = this.addMinutes(now, interval);
+				break;
+			case "GOOD":
+				newStep++;
+				if (newStep >= steps.length) {
+					isGraduated = true;
+					interval = this.config.graduatingInterval;
+					nextReviewAt = this.addDays(now, interval);
+				} else {
+					interval = steps[newStep] ?? 10;
+					nextReviewAt = this.addMinutes(now, interval);
+				}
+				break;
+			case "EASY":
+				isGraduated = true;
+				interval = this.config.easyInterval;
+				nextReviewAt = this.addDays(now, interval);
+				break;
+		}
+		return {
+			interval: isGraduated ? interval : 0,
+			easeFactor: state.easeFactor,
+			repetitions: isGraduated ? 1 : 0,
+			nextReviewAt,
+			learningStep: newStep,
+			isGraduated,
+			isRelearning: false,
+			lapses: state.lapses
+		};
+	}
+	/**
+	* Handle relearning phase (lapsed cards).
+	*/
+	handleRelearningCard(state, rating, now) {
+		const steps = this.config.relearningSteps;
+		let newStep = state.learningStep;
+		let isRelearning = true;
+		let interval = 0;
+		let nextReviewAt;
+		switch (rating) {
+			case "AGAIN":
+				newStep = 0;
+				interval = steps[0] ?? 10;
+				nextReviewAt = this.addMinutes(now, interval);
+				break;
+			case "HARD":
+				interval = steps[newStep] ?? steps[0] ?? 10;
+				nextReviewAt = this.addMinutes(now, interval);
+				break;
+			case "GOOD":
+				newStep++;
+				if (newStep >= steps.length) {
+					isRelearning = false;
+					interval = Math.max(1, Math.floor(state.interval * this.config.newIntervalModifier));
+					nextReviewAt = this.addDays(now, interval);
+				} else {
+					interval = steps[newStep] ?? 10;
+					nextReviewAt = this.addMinutes(now, interval);
+				}
+				break;
+			case "EASY":
+				isRelearning = false;
+				interval = Math.max(1, Math.floor(state.interval * this.config.newIntervalModifier * 1.5));
+				nextReviewAt = this.addDays(now, interval);
+				break;
+		}
+		return {
+			interval: isRelearning ? state.interval : interval,
+			easeFactor: state.easeFactor,
+			repetitions: isRelearning ? state.repetitions : state.repetitions + 1,
+			nextReviewAt,
+			learningStep: newStep,
+			isGraduated: true,
+			isRelearning,
+			lapses: state.lapses
+		};
+	}
+	/**
+	* Handle review phase (graduated cards).
+	*/
+	handleReviewCard(state, rating, now) {
+		let newInterval;
+		let newEaseFactor = state.easeFactor;
+		let repetitions = state.repetitions;
+		let isRelearning = false;
+		let learningStep = 0;
+		let lapses = state.lapses;
+		switch (rating) {
+			case "AGAIN":
+				lapses++;
+				isRelearning = true;
+				learningStep = 0;
+				newEaseFactor = Math.max(this.config.minEaseFactor, newEaseFactor - .2);
+				newInterval = state.interval;
+				const relearnStep = this.config.relearningSteps[0] ?? 10;
+				return {
+					interval: newInterval,
+					easeFactor: newEaseFactor,
+					repetitions,
+					nextReviewAt: this.addMinutes(now, relearnStep),
+					learningStep,
+					isGraduated: true,
+					isRelearning: true,
+					lapses
+				};
+			case "HARD":
+				newEaseFactor = Math.max(this.config.minEaseFactor, newEaseFactor - .15);
+				newInterval = Math.max(state.interval + 1, state.interval * this.config.hardIntervalModifier);
+				break;
+			case "GOOD":
+				newInterval = state.interval * newEaseFactor * this.config.intervalModifier;
+				repetitions++;
+				break;
+			case "EASY":
+				newEaseFactor = newEaseFactor + .15;
+				newInterval = state.interval * newEaseFactor * this.config.easyBonus * this.config.intervalModifier;
+				repetitions++;
+				break;
+		}
+		newInterval = Math.min(Math.round(newInterval), this.config.maxInterval);
+		newInterval = Math.max(1, newInterval);
+		return {
+			interval: newInterval,
+			easeFactor: newEaseFactor,
+			repetitions,
+			nextReviewAt: this.addDays(now, newInterval),
+			learningStep,
+			isGraduated: true,
+			isRelearning,
+			lapses
+		};
+	}
+	/**
+	* Get initial SRS state for a new card.
+	*/
+	getInitialState() {
+		return {
+			interval: 0,
+			easeFactor: 2.5,
+			repetitions: 0,
+			learningStep: 0,
+			isGraduated: false,
+			isRelearning: false,
+			lapses: 0
+		};
+	}
+	/**
+	* Check if a card is due for review.
+	*/
+	isDue(nextReviewAt, now = /* @__PURE__ */ new Date()) {
+		return nextReviewAt <= now;
+	}
+	/**
+	* Calculate overdue days (negative if not yet due).
+	*/
+	getOverdueDays(nextReviewAt, now = /* @__PURE__ */ new Date()) {
+		const diff = now.getTime() - nextReviewAt.getTime();
+		return Math.floor(diff / (1e3 * 60 * 60 * 24));
+	}
+	addMinutes(date, minutes) {
+		return new Date(date.getTime() + minutes * 60 * 1e3);
+	}
+	addDays(date, days) {
+		return new Date(date.getTime() + days * 24 * 60 * 60 * 1e3);
+	}
+};
+/**
+* Default SRS engine instance.
+*/
+const srsEngine = new SRSEngine();
+
+//#endregion
+export { DEFAULT_SRS_CONFIG, SRSEngine, srsEngine };

package/dist/engines/streak.js

@@ -1 +1,193 @@
-const e={timezone:`UTC`,freezesPerMonth:2,maxFreezes:5,gracePeriodHours:4};var t=class{config;constructor(t={}){this.config={...e,...t}}update(e,t=new Date){let n=this.getDateString(t),r={state:{...e},streakMaintained:!1,streakLost:!1,freezeUsed:!1,newStreak:!1,daysMissed:0};if(!e.lastActivityDate)return r.state.currentStreak=1,r.state.longestStreak=Math.max(1,e.longestStreak),r.state.lastActivityAt=t,r.state.lastActivityDate=n,r.newStreak=!0,r.streakMaintained=!0,r;if(e.lastActivityDate===n)return r.state.lastActivityAt=t,r.streakMaintained=!0,r;let i=this.getDaysBetween(e.lastActivityDate,n);if(i===1)return r.state.currentStreak=e.currentStreak+1,r.state.longestStreak=Math.max(r.state.currentStreak,e.longestStreak),r.state.lastActivityAt=t,r.state.lastActivityDate=n,r.streakMaintained=!0,r;r.daysMissed=i-1;let a=r.daysMissed;return a<=e.freezesRemaining?(r.state.freezesRemaining=e.freezesRemaining-a,r.state.freezeUsedAt=t,r.state.currentStreak=e.currentStreak+1,r.state.longestStreak=Math.max(r.state.currentStreak,e.longestStreak),r.state.lastActivityAt=t,r.state.lastActivityDate=n,r.freezeUsed=!0,r.streakMaintained=!0,r):(r.streakLost=!0,r.state.currentStreak=1,r.state.lastActivityAt=t,r.state.lastActivityDate=n,r.newStreak=!0,r)}checkStatus(e,t=new Date){if(!e.lastActivityDate)return{isActive:!1,willExpireAt:null,canUseFreeze:!1,daysUntilExpiry:0};let n=this.getDateString(t),r=this.getDaysBetween(e.lastActivityDate,n);if(r===0){let n=this.addDays(t,1);return n.setHours(23,59,59,999),{isActive:!0,willExpireAt:n,canUseFreeze:e.freezesRemaining>0,daysUntilExpiry:1}}if(r===1){let n=new Date(t);return n.setHours(23+this.config.gracePeriodHours,59,59,999),{isActive:!0,willExpireAt:n,canUseFreeze:e.freezesRemaining>0,daysUntilExpiry:0}}let i=r-1;return{isActive:i<=e.freezesRemaining,willExpireAt:null,canUseFreeze:i<=e.freezesRemaining,daysUntilExpiry:-i}}useFreeze(e,t=new Date){return e.freezesRemaining<=0?null:{...e,freezesRemaining:e.freezesRemaining-1,freezeUsedAt:t}}awardMonthlyFreezes(e){return{...e,freezesRemaining:Math.min(e.freezesRemaining+this.config.freezesPerMonth,this.config.maxFreezes)}}getInitialState(){return{currentStreak:0,longestStreak:0,lastActivityAt:null,lastActivityDate:null,freezesRemaining:this.config.freezesPerMonth,freezeUsedAt:null}}getMilestones(e){let t=[3,7,14,30,60,90,180,365,500,1e3];return{achieved:t.filter(t=>e>=t),next:t.find(t=>e<t)??null}}getDateString(e){return`${e.getFullYear()}-${String(e.getMonth()+1).padStart(2,`0`)}-${String(e.getDate()).padStart(2,`0`)}`}getDaysBetween(e,t){let n=new Date(e),r=new Date(t).getTime()-n.getTime();return Math.floor(r/(1e3*60*60*24))}addDays(e,t){return new Date(e.getTime()+t*24*60*60*1e3)}};const n=new t;export{e as DEFAULT_STREAK_CONFIG,t as StreakEngine,n as streakEngine};
+//#region src/engines/streak.ts
+const DEFAULT_STREAK_CONFIG = {
+	timezone: "UTC",
+	freezesPerMonth: 2,
+	maxFreezes: 5,
+	gracePeriodHours: 4
+};
+var StreakEngine = class {
+	config;
+	constructor(config = {}) {
+		this.config = {
+			...DEFAULT_STREAK_CONFIG,
+			...config
+		};
+	}
+	/**
+	* Update streak based on new activity.
+	*/
+	update(state, now = /* @__PURE__ */ new Date()) {
+		const todayDate = this.getDateString(now);
+		const result = {
+			state: { ...state },
+			streakMaintained: false,
+			streakLost: false,
+			freezeUsed: false,
+			newStreak: false,
+			daysMissed: 0
+		};
+		if (!state.lastActivityDate) {
+			result.state.currentStreak = 1;
+			result.state.longestStreak = Math.max(1, state.longestStreak);
+			result.state.lastActivityAt = now;
+			result.state.lastActivityDate = todayDate;
+			result.newStreak = true;
+			result.streakMaintained = true;
+			return result;
+		}
+		if (state.lastActivityDate === todayDate) {
+			result.state.lastActivityAt = now;
+			result.streakMaintained = true;
+			return result;
+		}
+		const daysSinceActivity = this.getDaysBetween(state.lastActivityDate, todayDate);
+		if (daysSinceActivity === 1) {
+			result.state.currentStreak = state.currentStreak + 1;
+			result.state.longestStreak = Math.max(result.state.currentStreak, state.longestStreak);
+			result.state.lastActivityAt = now;
+			result.state.lastActivityDate = todayDate;
+			result.streakMaintained = true;
+			return result;
+		}
+		result.daysMissed = daysSinceActivity - 1;
+		const freezesNeeded = result.daysMissed;
+		if (freezesNeeded <= state.freezesRemaining) {
+			result.state.freezesRemaining = state.freezesRemaining - freezesNeeded;
+			result.state.freezeUsedAt = now;
+			result.state.currentStreak = state.currentStreak + 1;
+			result.state.longestStreak = Math.max(result.state.currentStreak, state.longestStreak);
+			result.state.lastActivityAt = now;
+			result.state.lastActivityDate = todayDate;
+			result.freezeUsed = true;
+			result.streakMaintained = true;
+			return result;
+		}
+		result.streakLost = true;
+		result.state.currentStreak = 1;
+		result.state.lastActivityAt = now;
+		result.state.lastActivityDate = todayDate;
+		result.newStreak = true;
+		return result;
+	}
+	/**
+	* Check streak status without recording activity.
+	*/
+	checkStatus(state, now = /* @__PURE__ */ new Date()) {
+		if (!state.lastActivityDate) return {
+			isActive: false,
+			willExpireAt: null,
+			canUseFreeze: false,
+			daysUntilExpiry: 0
+		};
+		const todayDate = this.getDateString(now);
+		const daysSinceActivity = this.getDaysBetween(state.lastActivityDate, todayDate);
+		if (daysSinceActivity === 0) {
+			const tomorrow = this.addDays(now, 1);
+			tomorrow.setHours(23, 59, 59, 999);
+			return {
+				isActive: true,
+				willExpireAt: tomorrow,
+				canUseFreeze: state.freezesRemaining > 0,
+				daysUntilExpiry: 1
+			};
+		}
+		if (daysSinceActivity === 1) {
+			const endOfDay = new Date(now);
+			endOfDay.setHours(23 + this.config.gracePeriodHours, 59, 59, 999);
+			return {
+				isActive: true,
+				willExpireAt: endOfDay,
+				canUseFreeze: state.freezesRemaining > 0,
+				daysUntilExpiry: 0
+			};
+		}
+		const missedDays = daysSinceActivity - 1;
+		return {
+			isActive: missedDays <= state.freezesRemaining,
+			willExpireAt: null,
+			canUseFreeze: missedDays <= state.freezesRemaining,
+			daysUntilExpiry: -missedDays
+		};
+	}
+	/**
+	* Manually use a freeze to protect streak.
+	*/
+	useFreeze(state, now = /* @__PURE__ */ new Date()) {
+		if (state.freezesRemaining <= 0) return null;
+		return {
+			...state,
+			freezesRemaining: state.freezesRemaining - 1,
+			freezeUsedAt: now
+		};
+	}
+	/**
+	* Award monthly freezes.
+	*/
+	awardMonthlyFreezes(state) {
+		return {
+			...state,
+			freezesRemaining: Math.min(state.freezesRemaining + this.config.freezesPerMonth, this.config.maxFreezes)
+		};
+	}
+	/**
+	* Get initial streak state.
+	*/
+	getInitialState() {
+		return {
+			currentStreak: 0,
+			longestStreak: 0,
+			lastActivityAt: null,
+			lastActivityDate: null,
+			freezesRemaining: this.config.freezesPerMonth,
+			freezeUsedAt: null
+		};
+	}
+	/**
+	* Calculate streak milestones.
+	*/
+	getMilestones(currentStreak) {
+		const milestones = [
+			3,
+			7,
+			14,
+			30,
+			60,
+			90,
+			180,
+			365,
+			500,
+			1e3
+		];
+		return {
+			achieved: milestones.filter((m) => currentStreak >= m),
+			next: milestones.find((m) => currentStreak < m) ?? null
+		};
+	}
+	/**
+	* Get date string in YYYY-MM-DD format.
+	*/
+	getDateString(date) {
+		return `${date.getFullYear()}-${String(date.getMonth() + 1).padStart(2, "0")}-${String(date.getDate()).padStart(2, "0")}`;
+	}
+	/**
+	* Get number of days between two date strings.
+	*/
+	getDaysBetween(dateStr1, dateStr2) {
+		const date1 = new Date(dateStr1);
+		const diffTime = new Date(dateStr2).getTime() - date1.getTime();
+		return Math.floor(diffTime / (1e3 * 60 * 60 * 24));
+	}
+	/**
+	* Add days to a date.
+	*/
+	addDays(date, days) {
+		return new Date(date.getTime() + days * 24 * 60 * 60 * 1e3);
+	}
+};
+/**
+* Default streak engine instance.
+*/
+const streakEngine = new StreakEngine();
+
+//#endregion
+export { DEFAULT_STREAK_CONFIG, StreakEngine, streakEngine };

package/dist/engines/xp.js

@@ -1 +1,212 @@
-const e={baseValues:{lesson_complete:10,quiz_pass:20,quiz_perfect:50,flashcard_review:1,course_complete:200,module_complete:50,streak_bonus:5,achievement_unlock:0,daily_goal_complete:15,first_lesson:25,onboarding_step:5,onboarding_complete:50},scoreThresholds:[{min:90,multiplier:1.5},{min:80,multiplier:1.25},{min:70,multiplier:1},{min:60,multiplier:.75},{min:0,multiplier:.5}],streakTiers:[{days:365,bonus:50},{days:180,bonus:30},{days:90,bonus:20},{days:30,bonus:15},{days:14,bonus:10},{days:7,bonus:5},{days:3,bonus:2},{days:1,bonus:0}],perfectScoreMultiplier:1.5,firstAttemptBonus:10,retryPenalty:.5,speedBonusMultiplier:1.2,speedBonusThreshold:.8};var t=class{config;constructor(t={}){this.config={...e,...t,baseValues:{...e.baseValues,...t.baseValues},scoreThresholds:t.scoreThresholds||e.scoreThresholds,streakTiers:t.streakTiers||e.streakTiers}}calculate(e){let t=[],n=e.baseXp??this.config.baseValues[e.activity],r=n;if(t.push({source:`base`,amount:n}),e.score!==void 0){let i=this.getScoreMultiplier(e.score);if(i!==1){let e=Math.round(n*(i-1));r+=e,t.push({source:`score_bonus`,amount:e,multiplier:i})}if(e.score===100){let e=Math.round(n*(this.config.perfectScoreMultiplier-1));r+=e,t.push({source:`perfect_score`,amount:e,multiplier:this.config.perfectScoreMultiplier})}}if(e.attemptNumber===1&&!e.isRetry&&(r+=this.config.firstAttemptBonus,t.push({source:`first_attempt`,amount:this.config.firstAttemptBonus})),e.isRetry){let e=Math.round(r*(1-this.config.retryPenalty));r-=e,t.push({source:`retry_penalty`,amount:-e,multiplier:this.config.retryPenalty})}if(e.currentStreak&&e.currentStreak>0){let n=this.getStreakBonus(e.currentStreak);n>0&&(r+=n,t.push({source:`streak_bonus`,amount:n}))}return n>0&&(r=Math.max(1,r)),{totalXp:Math.round(r),baseXp:n,breakdown:t}}calculateStreakBonus(e){let t=this.getStreakBonus(e);return{totalXp:t,baseXp:t,breakdown:[{source:`streak_bonus`,amount:t}]}}getXpForLevel(e){return e<=1?0:Math.round(100*(e-1)**1.5)}getLevelFromXp(e){let t=1,n=this.getXpForLevel(t+1);for(;e>=n&&t<1e3;)t++,n=this.getXpForLevel(t+1);let r=this.getXpForLevel(t),i=this.getXpForLevel(t+1);return{level:t,xpInLevel:e-r,xpForNextLevel:i-r}}getScoreMultiplier(e){for(let t of this.config.scoreThresholds)if(e>=t.min)return t.multiplier;return 1}getStreakBonus(e){for(let t of this.config.streakTiers)if(e>=t.days)return t.bonus;return 0}};const n=new t;export{e as DEFAULT_XP_CONFIG,t as XPEngine,n as xpEngine};
+//#region src/engines/xp.ts
+const DEFAULT_XP_CONFIG = {
+	baseValues: {
+		lesson_complete: 10,
+		quiz_pass: 20,
+		quiz_perfect: 50,
+		flashcard_review: 1,
+		course_complete: 200,
+		module_complete: 50,
+		streak_bonus: 5,
+		achievement_unlock: 0,
+		daily_goal_complete: 15,
+		first_lesson: 25,
+		onboarding_step: 5,
+		onboarding_complete: 50
+	},
+	scoreThresholds: [
+		{
+			min: 90,
+			multiplier: 1.5
+		},
+		{
+			min: 80,
+			multiplier: 1.25
+		},
+		{
+			min: 70,
+			multiplier: 1
+		},
+		{
+			min: 60,
+			multiplier: .75
+		},
+		{
+			min: 0,
+			multiplier: .5
+		}
+	],
+	streakTiers: [
+		{
+			days: 365,
+			bonus: 50
+		},
+		{
+			days: 180,
+			bonus: 30
+		},
+		{
+			days: 90,
+			bonus: 20
+		},
+		{
+			days: 30,
+			bonus: 15
+		},
+		{
+			days: 14,
+			bonus: 10
+		},
+		{
+			days: 7,
+			bonus: 5
+		},
+		{
+			days: 3,
+			bonus: 2
+		},
+		{
+			days: 1,
+			bonus: 0
+		}
+	],
+	perfectScoreMultiplier: 1.5,
+	firstAttemptBonus: 10,
+	retryPenalty: .5,
+	speedBonusMultiplier: 1.2,
+	speedBonusThreshold: .8
+};
+var XPEngine = class {
+	config;
+	constructor(config = {}) {
+		this.config = {
+			...DEFAULT_XP_CONFIG,
+			...config,
+			baseValues: {
+				...DEFAULT_XP_CONFIG.baseValues,
+				...config.baseValues
+			},
+			scoreThresholds: config.scoreThresholds || DEFAULT_XP_CONFIG.scoreThresholds,
+			streakTiers: config.streakTiers || DEFAULT_XP_CONFIG.streakTiers
+		};
+	}
+	/**
+	* Calculate XP for an activity.
+	*/
+	calculate(input) {
+		const breakdown = [];
+		const baseXp = input.baseXp ?? this.config.baseValues[input.activity];
+		let totalXp = baseXp;
+		breakdown.push({
+			source: "base",
+			amount: baseXp
+		});
+		if (input.score !== void 0) {
+			const scoreMultiplier = this.getScoreMultiplier(input.score);
+			if (scoreMultiplier !== 1) {
+				const scoreBonus = Math.round(baseXp * (scoreMultiplier - 1));
+				totalXp += scoreBonus;
+				breakdown.push({
+					source: "score_bonus",
+					amount: scoreBonus,
+					multiplier: scoreMultiplier
+				});
+			}
+			if (input.score === 100) {
+				const perfectBonus = Math.round(baseXp * (this.config.perfectScoreMultiplier - 1));
+				totalXp += perfectBonus;
+				breakdown.push({
+					source: "perfect_score",
+					amount: perfectBonus,
+					multiplier: this.config.perfectScoreMultiplier
+				});
+			}
+		}
+		if (input.attemptNumber === 1 && !input.isRetry) {
+			totalXp += this.config.firstAttemptBonus;
+			breakdown.push({
+				source: "first_attempt",
+				amount: this.config.firstAttemptBonus
+			});
+		}
+		if (input.isRetry) {
+			const penalty = Math.round(totalXp * (1 - this.config.retryPenalty));
+			totalXp -= penalty;
+			breakdown.push({
+				source: "retry_penalty",
+				amount: -penalty,
+				multiplier: this.config.retryPenalty
+			});
+		}
+		if (input.currentStreak && input.currentStreak > 0) {
+			const streakBonus = this.getStreakBonus(input.currentStreak);
+			if (streakBonus > 0) {
+				totalXp += streakBonus;
+				breakdown.push({
+					source: "streak_bonus",
+					amount: streakBonus
+				});
+			}
+		}
+		if (baseXp > 0) totalXp = Math.max(1, totalXp);
+		return {
+			totalXp: Math.round(totalXp),
+			baseXp,
+			breakdown
+		};
+	}
+	/**
+	* Calculate streak bonus XP.
+	*/
+	calculateStreakBonus(currentStreak) {
+		const bonus = this.getStreakBonus(currentStreak);
+		return {
+			totalXp: bonus,
+			baseXp: bonus,
+			breakdown: [{
+				source: "streak_bonus",
+				amount: bonus
+			}]
+		};
+	}
+	/**
+	* Calculate XP needed for a level.
+	*/
+	getXpForLevel(level) {
+		if (level <= 1) return 0;
+		return Math.round(100 * Math.pow(level - 1, 1.5));
+	}
+	/**
+	* Get level from total XP.
+	*/
+	getLevelFromXp(totalXp) {
+		let level = 1;
+		let xpRequired = this.getXpForLevel(level + 1);
+		while (totalXp >= xpRequired && level < 1e3) {
+			level++;
+			xpRequired = this.getXpForLevel(level + 1);
+		}
+		const xpForCurrentLevel = this.getXpForLevel(level);
+		const xpForNextLevel = this.getXpForLevel(level + 1);
+		return {
+			level,
+			xpInLevel: totalXp - xpForCurrentLevel,
+			xpForNextLevel: xpForNextLevel - xpForCurrentLevel
+		};
+	}
+	getScoreMultiplier(score) {
+		for (const threshold of this.config.scoreThresholds) if (score >= threshold.min) return threshold.multiplier;
+		return 1;
+	}
+	getStreakBonus(streak) {
+		for (const tier of this.config.streakTiers) if (streak >= tier.days) return tier.bonus;
+		return 0;
+	}
+};
+/**
+* Default XP engine instance.
+*/
+const xpEngine = new XPEngine();
+
+//#endregion
+export { DEFAULT_XP_CONFIG, XPEngine, xpEngine };