@vue-skuilder/db 0.2.12 → 0.2.14

package/package.json

@@ -4,7 +4,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "0.2.12",
+  "version": "0.2.14",
   "description": "Database layer for vue-skuilder",
   "main": "dist/index.js",
   "module": "dist/index.mjs",
@@ -48,7 +48,7 @@
   },
   "dependencies": {
     "@nilock2/pouchdb-authentication": "^1.0.2",
-    "@vue-skuilder/common": "0.2.12",
+    "@vue-skuilder/common": "0.2.14",
     "cross-fetch": "^4.1.0",
     "moment": "^2.29.4",
     "pouchdb": "^9.0.0",
@@ -62,5 +62,5 @@
     "vite": "^8.0.0",
     "vitest": "^4.1.0"
   },
-  "stableVersion": "0.2.12"
+  "stableVersion": "0.2.14"
 }

package/src/impl/common/BaseUserDB.ts

@@ -214,6 +214,19 @@ Currently logged-in as ${this._username}.`
     }
 
     const ret = await this.syncStrategy.logout!();
+
+    // Mint a FRESH guest identity on logout rather than re-adopting whatever
+    // sk-guest-uuid happens to survive in localStorage. A stale UUID can point
+    // at an already-consumed guest DB (one previously migrated into a real
+    // account); re-adopting it would resurface that account's progress and, on
+    // the next signup, migrate it into the new account. Clearing the pointer
+    // forces accomodateGuest() to generate a new UUID + empty guest DB.
+    try {
+      localStorage.removeItem('sk-guest-uuid');
+    } catch (e) {
+      logger.warn('localStorage not available (Node.js environment):', e);
+    }
+
     // return to 'guest' mode
     this._username = await this.syncStrategy.getCurrentUsername();
     await this.init();

package/src/impl/couch/CouchDBSyncStrategy.ts

@@ -228,6 +228,23 @@ export class CouchDBSyncStrategy implements SyncStrategy {
         logger.info('No documents to migrate from funnel account');
       }
 
+      // Destroy the consumed guest DB so it can never be re-migrated into a
+      // future account. Without this, an orphaned userdb-sk-guest-<uuid> lingers
+      // in IndexedDB indefinitely; if its stale identity is later re-adopted
+      // (e.g. on logout via a surviving sk-guest-uuid), its progress bleeds into
+      // the next new account. Best-effort: migration has already succeeded, so a
+      // teardown failure must not fail account creation.
+      try {
+        await oldLocalDB.destroy();
+        logger.info(`Destroyed consumed guest DB for ${oldUsername}`);
+      } catch (destroyErr) {
+        logger.warn(
+          `Failed to destroy consumed guest DB for ${oldUsername} (non-fatal): ${
+            destroyErr instanceof Error ? destroyErr.message : String(destroyErr)
+          }`
+        );
+      }
+
       return { success: true };
     } catch (error) {
       logger.error('Migration failed:', error);

package/src/study/services/EloService.ts

@@ -41,14 +41,20 @@ export class EloService {
       logger.warn(`k value interpretation not currently implemented`);
     }
     const courseDB = this.dataLayer.getCourseDB(currentCard.card.course_id);
-    const userElo = toCourseElo(
-      userCourseRegDoc.courses.find((c) => c.courseID === course_id)!.elo
-    );
+    const courseReg = userCourseRegDoc.courses.find((c) => c.courseID === course_id);
+    if (!courseReg) {
+      logger.error(
+        `[EloService] No registration for course ${course_id} on user's registration doc — ` +
+          `skipping ELO update for card ${card_id}. (Is the user registered for this course?)`
+      );
+      return;
+    }
+    const userElo = toCourseElo(courseReg.elo);
     const cardElo = (await courseDB.getCardEloData([currentCard.card.card_id]))[0];
 
     if (cardElo && userElo) {
       const eloUpdate = adjustCourseScores(userElo, cardElo, userScore);
-      userCourseRegDoc.courses.find((c) => c.courseID === course_id)!.elo = eloUpdate.userElo;
+      courseReg.elo = eloUpdate.userElo;
 
       const results = await Promise.allSettled([
         this.user.updateUserElo(course_id, eloUpdate.userElo),
@@ -108,9 +114,15 @@ export class EloService {
     currentCard: StudySessionRecord
   ): Promise<void> {
     const courseDB = this.dataLayer.getCourseDB(currentCard.card.course_id);
-    const userElo = toCourseElo(
-      userCourseRegDoc.courses.find((c) => c.courseID === course_id)!.elo
-    );
+    const courseReg = userCourseRegDoc.courses.find((c) => c.courseID === course_id);
+    if (!courseReg) {
+      logger.error(
+        `[EloService] No registration for course ${course_id} on user's registration doc — ` +
+          `skipping per-tag ELO update for card ${card_id}. (Is the user registered for this course?)`
+      );
+      return;
+    }
+    const userElo = toCourseElo(courseReg.elo);
 
     const [cardEloResults, cardTagsMap] = await Promise.all([
       courseDB.getCardEloData([currentCard.card.card_id]),
@@ -134,7 +146,7 @@ export class EloService {
 
     if (cardElo && userElo) {
       const eloUpdate = adjustCourseScoresPerTag(userElo, cardElo, enriched);
-      userCourseRegDoc.courses.find((c) => c.courseID === course_id)!.elo = eloUpdate.userElo;
+      courseReg.elo = eloUpdate.userElo;
 
       const results = await Promise.allSettled([
         this.user.updateUserElo(course_id, eloUpdate.userElo),

package/src/study/services/ResponseProcessor.ts

@@ -35,6 +35,16 @@ export class ResponseProcessor {
     this.eloService = eloService;
   }
 
+  /**
+   * ELO updates are fired without awaiting so response handling isn't blocked
+   * on DB writes — but an unhandled rejection silently drops the update.
+   * This produces a catch handler that surfaces the failure in logs.
+   */
+  private logEloFailure(context: string, cardId: string): (e: unknown) => void {
+    return (e) =>
+      logger.error(`[ResponseProcessor] ELO update failed (${context}) for ${cardId}:`, e);
+  }
+
   /**
    * Parses performance data into global score and optional per-tag scores.
    *
@@ -194,37 +204,37 @@ export class ResponseProcessor {
             `scored=[${scoredTags.join(', ')}] count-only=[${nullTags.join(', ')}]`
         );
 
-        void this.eloService.updateUserAndCardEloPerTag(
-          taggedPerformance,
-          courseId,
-          cardId,
-          courseRegistrationDoc,
-          currentCard
-        );
+        void this.eloService
+          .updateUserAndCardEloPerTag(
+            taggedPerformance,
+            courseId,
+            cardId,
+            courseRegistrationDoc,
+            currentCard
+          )
+          .catch(this.logEloFailure('correct per-tag', cardId));
       } else {
         // Standard single-score ELO update (backward compatible)
         const userScore = 0.5 + globalScore / 2;
 
         if (history.records.length === 1) {
           // First interaction with this card - standard ELO update
-          void this.eloService.updateUserAndCardElo(
-            userScore,
-            courseId,
-            cardId,
-            courseRegistrationDoc,
-            currentCard
-          );
+          void this.eloService
+            .updateUserAndCardElo(userScore, courseId, cardId, courseRegistrationDoc, currentCard)
+            .catch(this.logEloFailure('correct', cardId));
         } else {
           // Multiple interactions - reduce K-factor to limit ELO volatility
           const k = Math.ceil(32 / history.records.length);
-          void this.eloService.updateUserAndCardElo(
-            userScore,
-            courseId,
-            cardId,
-            courseRegistrationDoc,
-            currentCard,
-            k
-          );
+          void this.eloService
+            .updateUserAndCardElo(
+              userScore,
+              courseId,
+              cardId,
+              courseRegistrationDoc,
+              currentCard,
+              k
+            )
+            .catch(this.logEloFailure('correct repeat-view', cardId));
         }
         logger.info(
           `[FirstContactElo] correct first-attempt ELO update (score=${userScore.toFixed(3)}) ` +
@@ -286,13 +296,15 @@ export class ResponseProcessor {
     if (cardRecord.priorAttemps === 0) {
       if (taggedPerformance) {
         // Per-tag ELO update for incorrect response
-        void this.eloService.updateUserAndCardEloPerTag(
-          taggedPerformance,
-          courseId,
-          cardId,
-          courseRegistrationDoc,
-          currentCard
-        );
+        void this.eloService
+          .updateUserAndCardEloPerTag(
+            taggedPerformance,
+            courseId,
+            cardId,
+            courseRegistrationDoc,
+            currentCard
+          )
+          .catch(this.logEloFailure('incorrect per-tag', cardId));
         logger.info(
           `[FirstContactElo] incorrect first-attempt per-tag ELO update for ${cardId} ` +
             `(historyLen=${history.records.length}, priorAttemps=${cardRecord.priorAttemps}, ` +
@@ -300,13 +312,15 @@ export class ResponseProcessor {
         );
       } else {
         // Standard single-score ELO update
-        void this.eloService.updateUserAndCardElo(
-          0, // Failed response = 0 score
-          courseId,
-          cardId,
-          courseRegistrationDoc,
-          currentCard
-        );
+        void this.eloService
+          .updateUserAndCardElo(
+            0, // Failed response = 0 score
+            courseId,
+            cardId,
+            courseRegistrationDoc,
+            currentCard
+          )
+          .catch(this.logEloFailure('incorrect', cardId));
         logger.info(
           `[FirstContactElo] incorrect first-attempt ELO update (score=0) for ${cardId} ` +
             `(historyLen=${history.records.length}, priorAttemps=${cardRecord.priorAttemps})`
@@ -329,21 +343,19 @@ export class ResponseProcessor {
         if (!eloUpdated) {
           if (taggedPerformance) {
             // Use tagged performance for final failure
-            void this.eloService.updateUserAndCardEloPerTag(
-              taggedPerformance,
-              courseId,
-              cardId,
-              courseRegistrationDoc,
-              currentCard
-            );
+            void this.eloService
+              .updateUserAndCardEloPerTag(
+                taggedPerformance,
+                courseId,
+                cardId,
+                courseRegistrationDoc,
+                currentCard
+              )
+              .catch(this.logEloFailure('dismiss-failed per-tag', cardId));
           } else {
-            void this.eloService.updateUserAndCardElo(
-              0,
-              courseId,
-              cardId,
-              courseRegistrationDoc,
-              currentCard
-            );
+            void this.eloService
+              .updateUserAndCardElo(0, courseId, cardId, courseRegistrationDoc, currentCard)
+              .catch(this.logEloFailure('dismiss-failed', cardId));
           }
           logger.info(
             `[FirstContactElo] dismiss-failed final ELO penalty for ${cardId} ` +