@vue-skuilder/db 0.1.11 → 0.1.12

package/dist/index.js

@@ -468,7 +468,9 @@ var init_updateQueue = __esm({
       async applyUpdates(id) {
         logger.debug(`Applying updates on doc: ${id}`);
         if (this.inprogressUpdates[id]) {
-          await this.readDB.info();
+          while (this.inprogressUpdates[id]) {
+            await new Promise((resolve) => setTimeout(resolve, Math.random() * 50));
+          }
           return this.applyUpdates(id);
         } else {
           if (this.pendingUpdates[id] && this.pendingUpdates[id].length > 0) {
@@ -504,6 +506,9 @@ var init_updateQueue = __esm({
                 if (e.name === "conflict" && i < MAX_RETRIES - 1) {
                   logger.warn(`Conflict on update for doc ${id}, retry #${i + 1}`);
                   await new Promise((res) => setTimeout(res, 50 * Math.random()));
+                } else if (e.name === "not_found" && i === 0) {
+                  logger.warn(`Update failed for ${id} - does not exist. Throwing to caller.`);
+                  throw e;
                 } else {
                   delete this.inprogressUpdates[id];
                   if (this.pendingUpdates[id]) {
@@ -982,12 +987,74 @@ var init_elo = __esm({
   }
 });
 
+// src/core/navigators/hardcodedOrder.ts
+var hardcodedOrder_exports = {};
+__export(hardcodedOrder_exports, {
+  default: () => HardcodedOrderNavigator
+});
+var HardcodedOrderNavigator;
+var init_hardcodedOrder = __esm({
+  "src/core/navigators/hardcodedOrder.ts"() {
+    "use strict";
+    init_navigators();
+    init_logger();
+    HardcodedOrderNavigator = class extends ContentNavigator {
+      orderedCardIds = [];
+      user;
+      course;
+      constructor(user, course, strategyData) {
+        super();
+        this.user = user;
+        this.course = course;
+        if (strategyData.serializedData) {
+          try {
+            this.orderedCardIds = JSON.parse(strategyData.serializedData);
+          } catch (e) {
+            logger.error("Failed to parse serializedData for HardcodedOrderNavigator", e);
+          }
+        }
+      }
+      async getPendingReviews() {
+        const reviews = await this.user.getPendingReviews(this.course.getCourseID());
+        return reviews.map((r) => {
+          return {
+            ...r,
+            contentSourceType: "course",
+            contentSourceID: this.course.getCourseID(),
+            cardID: r.cardId,
+            courseID: r.courseId,
+            reviewID: r._id,
+            status: "review"
+          };
+        });
+      }
+      async getNewCards(limit = 99) {
+        const activeCardIds = (await this.user.getActiveCards()).map((c) => c.cardID);
+        const newCardIds = this.orderedCardIds.filter(
+          (cardId) => !activeCardIds.includes(cardId)
+        );
+        const cardsToReturn = newCardIds.slice(0, limit);
+        return cardsToReturn.map((cardId) => {
+          return {
+            cardID: cardId,
+            courseID: this.course.getCourseID(),
+            contentSourceType: "course",
+            contentSourceID: this.course.getCourseID(),
+            status: "new"
+          };
+        });
+      }
+    };
+  }
+});
+
 // import("./**/*") in src/core/navigators/index.ts
 var globImport;
 var init_ = __esm({
   'import("./**/*") in src/core/navigators/index.ts'() {
     globImport = __glob({
       "./elo.ts": () => Promise.resolve().then(() => (init_elo(), elo_exports)),
+      "./hardcodedOrder.ts": () => Promise.resolve().then(() => (init_hardcodedOrder(), hardcodedOrder_exports)),
       "./index.ts": () => Promise.resolve().then(() => (init_navigators(), navigators_exports))
     });
   }
@@ -1007,6 +1074,7 @@ var init_navigators = __esm({
     init_();
     Navigators = /* @__PURE__ */ ((Navigators2) => {
       Navigators2["ELO"] = "elo";
+      Navigators2["HARDCODED"] = "hardcodedOrder";
       return Navigators2;
     })(Navigators || {});
     ContentNavigator = class {
@@ -1276,6 +1344,23 @@ var init_courseDB = __esm({
         if (!doc.docType || !(doc.docType === "CARD" /* CARD */)) {
           throw new Error(`failed to remove ${id} from course ${this.id}. id does not point to a card`);
         }
+        try {
+          const appliedTags = await this.getAppliedTags(id);
+          const results = await Promise.allSettled(
+            appliedTags.rows.map(async (tagRow) => {
+              const tagId = tagRow.id;
+              await this.removeTagFromCard(id, tagId);
+            })
+          );
+          results.forEach((result, index) => {
+            if (result.status === "rejected") {
+              const tagId = appliedTags.rows[index].id;
+              logger.error(`Failed to remove card ${id} from tag ${tagId}: ${result.reason}`);
+            }
+          });
+        } catch (error) {
+          logger.error(`Error removing card ${id} from tags: ${error}`);
+        }
         return this.db.remove(doc);
       }
       async getCardDisplayableDataIDs(id) {
@@ -1459,23 +1544,9 @@ ${above.rows.map((r) => `	${r.id}-${r.key}
       ////////////////////////////////////
       getNavigationStrategy(id) {
         logger.debug(`[courseDB] Getting navigation strategy: ${id}`);
-        const strategy = {
-          id: "ELO",
-          docType: "NAVIGATION_STRATEGY" /* NAVIGATION_STRATEGY */,
-          name: "ELO",
-          description: "ELO-based navigation strategy for ordering content by difficulty",
-          implementingClass: "elo" /* ELO */,
-          course: this.id,
-          serializedData: ""
-          // serde is a noop for ELO navigator.
-        };
-        return Promise.resolve(strategy);
-      }
-      getAllNavigationStrategies() {
-        logger.debug("[courseDB] Returning hard-coded navigation strategies");
-        const strategies = [
-          {
-            id: "ELO",
+        if (id == "") {
+          const strategy = {
+            _id: "NAVIGATION_STRATEGY-ELO",
             docType: "NAVIGATION_STRATEGY" /* NAVIGATION_STRATEGY */,
             name: "ELO",
             description: "ELO-based navigation strategy for ordering content by difficulty",
@@ -1483,14 +1554,25 @@ ${above.rows.map((r) => `	${r.id}-${r.key}
             course: this.id,
             serializedData: ""
             // serde is a noop for ELO navigator.
-          }
-        ];
-        return Promise.resolve(strategies);
+          };
+          return Promise.resolve(strategy);
+        } else {
+          return this.db.get(id);
+        }
       }
-      addNavigationStrategy(data) {
-        logger.debug(`[courseDB] Adding navigation strategy: ${data.id}`);
-        logger.debug(JSON.stringify(data));
-        return Promise.resolve();
+      async getAllNavigationStrategies() {
+        const prefix = DocTypePrefixes["NAVIGATION_STRATEGY" /* NAVIGATION_STRATEGY */];
+        const result = await this.db.allDocs({
+          startkey: prefix,
+          endkey: `${prefix}\uFFF0`,
+          include_docs: true
+        });
+        return result.rows.map((row) => row.doc);
+      }
+      async addNavigationStrategy(data) {
+        logger.debug(`[courseDB] Adding navigation strategy: ${data._id}`);
+        return this.db.put(data).then(() => {
+        });
       }
       updateNavigationStrategy(id, data) {
         logger.debug(`[courseDB] Updating navigation strategy: ${id}`);
@@ -1498,9 +1580,32 @@ ${above.rows.map((r) => `	${r.id}-${r.key}
         return Promise.resolve();
       }
       async surfaceNavigationStrategy() {
+        try {
+          const config = await this.getCourseConfig();
+          if (config.defaultNavigationStrategyId) {
+            try {
+              const strategy = await this.getNavigationStrategy(config.defaultNavigationStrategyId);
+              if (strategy) {
+                logger.debug(`Surfacing strategy ${strategy.name} from course config`);
+                return strategy;
+              }
+            } catch (e) {
+              logger.warn(
+                // @ts-expect-error tmp: defaultNavigationStrategyId property does not yet exist
+                `Failed to load strategy '${config.defaultNavigationStrategyId}' specified in course config. Falling back to ELO.`,
+                e
+              );
+            }
+          }
+        } catch (e) {
+          logger.warn(
+            "Could not retrieve course config to determine navigation strategy. Falling back to ELO.",
+            e
+          );
+        }
         logger.warn(`Returning hard-coded default ELO navigator`);
         const ret = {
-          id: "ELO",
+          _id: "NAVIGATION_STRATEGY-ELO",
           docType: "NAVIGATION_STRATEGY" /* NAVIGATION_STRATEGY */,
           name: "ELO",
           description: "ELO-based navigation strategy",
@@ -2964,17 +3069,21 @@ Currently logged-in as ${this._username}.`
         } catch (e) {
           const reason = e;
           if (reason.status === 404) {
-            const initCardHistory = {
-              _id: cardHistoryID,
-              cardID: record.cardID,
-              courseID: record.courseID,
-              records: [record],
-              lapses: 0,
-              streak: 0,
-              bestInterval: 0
-            };
-            const putResult = await this.writeDB.put(initCardHistory);
-            return { ...initCardHistory, _rev: putResult.rev };
+            try {
+              const initCardHistory = {
+                _id: cardHistoryID,
+                cardID: record.cardID,
+                courseID: record.courseID,
+                records: [record],
+                lapses: 0,
+                streak: 0,
+                bestInterval: 0
+              };
+              const putResult = await this.writeDB.put(initCardHistory);
+              return { ...initCardHistory, _rev: putResult.rev };
+            } catch (creationError) {
+              throw new Error(`Failed to create CardHistory for ${cardHistoryID}. Reason: ${creationError}`);
+            }
           } else {
             throw new Error(`putCardRecord failed because of:
   name:${reason.name}
@@ -3754,16 +3863,20 @@ var init_courseDB2 = __esm({
       async updateCardElo(cardId, _elo) {
         return { ok: true, id: cardId, rev: "1-static" };
       }
-      async getNewCards(limit) {
-        const cardIds = await this.unpacker.queryByElo(1e3, limit || 10);
-        return cardIds.map((cardId) => ({
-          status: "new",
-          qualifiedID: `${this.courseId}-${cardId}`,
-          cardID: cardId,
-          contentSourceType: "course",
-          contentSourceID: this.courseId,
-          courseID: this.courseId
-        }));
+      async getNewCards(limit = 99) {
+        const activeCards = await this.userDB.getActiveCards();
+        return (await this.getCardsCenteredAtELO({ limit, elo: "user" }, (c) => {
+          if (activeCards.some((ac) => c.cardID === ac.cardID)) {
+            return false;
+          } else {
+            return true;
+          }
+        })).map((c) => {
+          return {
+            ...c,
+            status: "new"
+          };
+        });
       }
       async getCardsCenteredAtELO(options, filter) {
         let targetElo = typeof options.elo === "number" ? options.elo : 1e3;
@@ -3944,7 +4057,7 @@ var init_courseDB2 = __esm({
       // Navigation Strategy Manager implementation
       async getNavigationStrategy(_id) {
         return {
-          id: "ELO",
+          _id: "NAVIGATION_STRATEGY-ELO",
           docType: "NAVIGATION_STRATEGY" /* NAVIGATION_STRATEGY */,
           name: "ELO",
           description: "ELO-based navigation strategy",
@@ -4009,11 +4122,17 @@ var init_coursesDB = __esm({
         this.manifests = manifests;
       }
       async getCourseConfig(courseId) {
-        if (!this.manifests[courseId]) {
-          logger.warn(`Course ${courseId} not found`);
-          return {};
+        const manifest = this.manifests[courseId];
+        if (!manifest) {
+          logger.warn(`Course manifest for ${courseId} not found`);
+          throw new Error(`Course ${courseId} not found`);
+        }
+        if (manifest.courseConfig) {
+          return manifest.courseConfig;
+        } else {
+          logger.warn(`Course config not found in manifest for course ${courseId}`);
+          throw new Error(`Course config not found for course ${courseId}`);
         }
-        return {};
       }
       async getCourseList() {
         return Object.keys(this.manifests).map(
@@ -4105,23 +4224,49 @@ var init_StaticDataLayerProvider = __esm({
       config;
       initialized = false;
       courseUnpackers = /* @__PURE__ */ new Map();
+      manifests = {};
       constructor(config) {
         this.config = {
-          staticContentPath: config.staticContentPath || "/static-courses",
           localStoragePrefix: config.localStoragePrefix || "skuilder-static",
-          manifests: config.manifests || {}
+          rootManifest: config.rootManifest || { dependencies: {} },
+          rootManifestUrl: config.rootManifestUrl || "/"
         };
       }
+      async resolveCourseDependencies() {
+        logger.info("[StaticDataLayerProvider] Starting course dependency resolution...");
+        const rootManifest = this.config.rootManifest;
+        for (const [courseName, courseUrl] of Object.entries(rootManifest.dependencies || {})) {
+          try {
+            logger.debug(`[StaticDataLayerProvider] Resolving dependency: ${courseName} from ${courseUrl}`);
+            const courseManifestUrl = new URL(courseUrl, this.config.rootManifestUrl).href;
+            const courseJsonResponse = await fetch(courseManifestUrl);
+            if (!courseJsonResponse.ok) {
+              throw new Error(`Failed to fetch course manifest for ${courseName}`);
+            }
+            const courseJson = await courseJsonResponse.json();
+            if (courseJson.content && courseJson.content.manifest) {
+              const baseUrl = new URL(".", courseManifestUrl).href;
+              const finalManifestUrl = new URL(courseJson.content.manifest, courseManifestUrl).href;
+              const finalManifestResponse = await fetch(finalManifestUrl);
+              if (!finalManifestResponse.ok) {
+                throw new Error(`Failed to fetch final content manifest for ${courseName} at ${finalManifestUrl}`);
+              }
+              const finalManifest = await finalManifestResponse.json();
+              this.manifests[courseName] = finalManifest;
+              const unpacker = new StaticDataUnpacker(finalManifest, baseUrl);
+              this.courseUnpackers.set(courseName, unpacker);
+              logger.info(`[StaticDataLayerProvider] Successfully resolved and prepared course: ${courseName}`);
+            }
+          } catch (e) {
+            logger.error(`[StaticDataLayerProvider] Failed to resolve dependency ${courseName}:`, e);
+          }
+        }
+        logger.info("[StaticDataLayerProvider] Course dependency resolution complete.");
+      }
       async initialize() {
         if (this.initialized) return;
         logger.info("Initializing static data layer provider");
-        for (const [courseId, manifest] of Object.entries(this.config.manifests)) {
-          const unpacker = new StaticDataUnpacker(
-            manifest,
-            `${this.config.staticContentPath}/${courseId}`
-          );
-          this.courseUnpackers.set(courseId, unpacker);
-        }
+        await this.resolveCourseDependencies();
         this.initialized = true;
       }
       async teardown() {
@@ -4135,13 +4280,13 @@ var init_StaticDataLayerProvider = __esm({
       getCourseDB(courseId) {
         const unpacker = this.courseUnpackers.get(courseId);
         if (!unpacker) {
-          throw new Error(`Course ${courseId} not found in static data`);
+          throw new Error(`Course ${courseId} not found or failed to initialize in static data layer.`);
         }
-        const manifest = this.config.manifests[courseId];
+        const manifest = this.manifests[courseId];
         return new StaticCourseDB(courseId, unpacker, this.getUserDB(), manifest);
       }
       getCoursesDB() {
-        return new StaticCoursesDB(this.config.manifests);
+        return new StaticCoursesDB(this.manifests);
       }
       async getClassroomDB(_classId, _type) {
         throw new Error("Classrooms not supported in static mode");
@@ -4490,6 +4635,497 @@ module.exports = __toCommonJS(index_exports);
 init_core();
 init_courseLookupDB();
 
+// src/study/services/SrsService.ts
+var import_moment7 = __toESM(require("moment"));
+init_couch();
+
+// src/study/SpacedRepetition.ts
+init_util();
+var import_moment6 = __toESM(require("moment"));
+init_logger();
+var duration = import_moment6.default.duration;
+function newInterval(user, cardHistory) {
+  if (areQuestionRecords(cardHistory)) {
+    return newQuestionInterval(user, cardHistory);
+  } else {
+    return 1e5;
+  }
+}
+function newQuestionInterval(user, cardHistory) {
+  const records = cardHistory.records;
+  const currentAttempt = records[records.length - 1];
+  const lastInterval = lastSuccessfulInterval(records);
+  if (lastInterval > cardHistory.bestInterval) {
+    cardHistory.bestInterval = lastInterval;
+    void user.update(cardHistory._id, {
+      bestInterval: lastInterval
+    });
+  }
+  if (currentAttempt.isCorrect) {
+    const skill = Math.min(1, Math.max(0, currentAttempt.performance));
+    logger.debug(`Demontrated skill: 	${skill}`);
+    const interval = lastInterval * (0.75 + skill);
+    cardHistory.lapses = getLapses(cardHistory.records);
+    cardHistory.streak = getStreak(cardHistory.records);
+    if (cardHistory.lapses && cardHistory.streak && cardHistory.bestInterval && (cardHistory.lapses >= 0 || cardHistory.streak >= 0)) {
+      const ret = (cardHistory.lapses * interval + cardHistory.streak * cardHistory.bestInterval) / (cardHistory.lapses + cardHistory.streak);
+      logger.debug(`Weighted average interval calculation:
+	(${cardHistory.lapses} * ${interval} + ${cardHistory.streak} * ${cardHistory.bestInterval}) / (${cardHistory.lapses} + ${cardHistory.streak}) = ${ret}`);
+      return ret;
+    } else {
+      return interval;
+    }
+  } else {
+    return 0;
+  }
+}
+function lastSuccessfulInterval(cardHistory) {
+  for (let i = cardHistory.length - 1; i >= 1; i--) {
+    if (cardHistory[i].priorAttemps === 0 && cardHistory[i].isCorrect) {
+      const lastInterval = secondsBetween(cardHistory[i - 1].timeStamp, cardHistory[i].timeStamp);
+      const ret = Math.max(lastInterval, 20 * 60 * 60);
+      logger.debug(`Last interval w/ this card was: ${lastInterval}s, returning ${ret}s`);
+      return ret;
+    }
+  }
+  return getInitialInterval(cardHistory);
+}
+function getStreak(records) {
+  let streak = 0;
+  let index = records.length - 1;
+  while (index >= 0 && records[index].isCorrect) {
+    index--;
+    streak++;
+  }
+  return streak;
+}
+function getLapses(records) {
+  return records.filter((r) => r.isCorrect === false).length;
+}
+function getInitialInterval(cardHistory) {
+  logger.warn(`history of length: ${cardHistory.length} ignored!`);
+  return 60 * 60 * 24 * 3;
+}
+function secondsBetween(start, end) {
+  start = (0, import_moment6.default)(start);
+  end = (0, import_moment6.default)(end);
+  const ret = duration(end.diff(start)).asSeconds();
+  return ret;
+}
+
+// src/study/services/SrsService.ts
+init_logger();
+var SrsService = class {
+  user;
+  constructor(user) {
+    this.user = user;
+  }
+  /**
+   * Calculates the next review time for a card based on its history and
+   * schedules it in the user's database.
+   * @param history The full history of the card.
+   * @param item The study session item, used to determine if a previous review needs to be cleared.
+   */
+  async scheduleReview(history, item) {
+    const nextInterval = newInterval(this.user, history);
+    const nextReviewTime = import_moment7.default.utc().add(nextInterval, "seconds");
+    if (isReview(item)) {
+      logger.info(`[SrsService] Removing previously scheduled review for: ${item.cardID}`);
+      void this.user.removeScheduledCardReview(item.reviewID);
+    }
+    void this.user.scheduleCardReview({
+      user: this.user.getUsername(),
+      course_id: history.courseID,
+      card_id: history.cardID,
+      time: nextReviewTime,
+      scheduledFor: item.contentSourceType,
+      schedulingAgentId: item.contentSourceID
+    });
+  }
+};
+
+// src/study/services/EloService.ts
+var import_common15 = require("@vue-skuilder/common");
+init_logger();
+var EloService = class {
+  dataLayer;
+  user;
+  constructor(dataLayer, user) {
+    this.dataLayer = dataLayer;
+    this.user = user;
+  }
+  /**
+   * Updates both user and card ELO ratings based on user performance.
+   * @param userScore Score between 0-1 representing user performance
+   * @param course_id Course identifier
+   * @param card_id Card identifier  
+   * @param userCourseRegDoc User's course registration document (will be mutated)
+   * @param currentCard Current card session record
+   * @param k Optional K-factor for ELO calculation
+   */
+  async updateUserAndCardElo(userScore, course_id, card_id, userCourseRegDoc, currentCard, k) {
+    if (k) {
+      logger.warn(`k value interpretation not currently implemented`);
+    }
+    const courseDB = this.dataLayer.getCourseDB(currentCard.card.course_id);
+    const userElo = (0, import_common15.toCourseElo)(userCourseRegDoc.courses.find((c) => c.courseID === course_id).elo);
+    const cardElo = (await courseDB.getCardEloData([currentCard.card.card_id]))[0];
+    if (cardElo && userElo) {
+      const eloUpdate = (0, import_common15.adjustCourseScores)(userElo, cardElo, userScore);
+      userCourseRegDoc.courses.find((c) => c.courseID === course_id).elo = eloUpdate.userElo;
+      const results = await Promise.allSettled([
+        this.user.updateUserElo(course_id, eloUpdate.userElo),
+        courseDB.updateCardElo(card_id, eloUpdate.cardElo)
+      ]);
+      const userEloStatus = results[0].status === "fulfilled";
+      const cardEloStatus = results[1].status === "fulfilled";
+      if (userEloStatus && cardEloStatus) {
+        const user = results[0].value;
+        const card = results[1].value;
+        if (user.ok && card && card.ok) {
+          logger.info(
+            `[EloService] Updated ELOS:
+            	User: ${JSON.stringify(eloUpdate.userElo)})
+            	Card: ${JSON.stringify(eloUpdate.cardElo)})
+            `
+          );
+        }
+      } else {
+        logger.warn(
+          `[EloService] Partial ELO update:
+          	User ELO update: ${userEloStatus ? "SUCCESS" : "FAILED"}
+          	Card ELO update: ${cardEloStatus ? "SUCCESS" : "FAILED"}`
+        );
+        if (!userEloStatus && results[0].status === "rejected") {
+          logger.error("[EloService] User ELO update error:", results[0].reason);
+        }
+        if (!cardEloStatus && results[1].status === "rejected") {
+          logger.error("[EloService] Card ELO update error:", results[1].reason);
+        }
+      }
+    }
+  }
+};
+
+// src/study/services/ResponseProcessor.ts
+init_core();
+init_logger();
+var ResponseProcessor = class {
+  srsService;
+  eloService;
+  constructor(srsService, eloService) {
+    this.srsService = srsService;
+    this.eloService = eloService;
+  }
+  /**
+   * Processes a user's response to a card, handling SRS scheduling and ELO updates.
+   * @param cardRecord User's response record
+   * @param cardHistory Promise resolving to the card's history
+   * @param studySessionItem Current study session item
+   * @param courseRegistrationDoc User's course registration (for ELO updates)
+   * @param currentCard Current study session record
+   * @param courseId Course identifier
+   * @param cardId Card identifier
+   * @param maxAttemptsPerView Maximum attempts allowed per view
+   * @param maxSessionViews Maximum session views for this card
+   * @param sessionViews Current number of session views
+   * @returns ResponseResult with navigation and UI instructions
+   */
+  async processResponse(cardRecord, cardHistory, studySessionItem, courseRegistrationDoc, currentCard, courseId, cardId, maxAttemptsPerView, maxSessionViews, sessionViews) {
+    if (!isQuestionRecord(cardRecord)) {
+      return {
+        nextCardAction: "dismiss-success",
+        shouldLoadNextCard: true,
+        isCorrect: true,
+        // non-question records are considered "correct"
+        shouldClearFeedbackShadow: true
+      };
+    }
+    const history = await cardHistory;
+    if (cardRecord.isCorrect) {
+      return this.processCorrectResponse(
+        cardRecord,
+        history,
+        studySessionItem,
+        courseRegistrationDoc,
+        currentCard,
+        courseId,
+        cardId
+      );
+    } else {
+      return this.processIncorrectResponse(
+        cardRecord,
+        history,
+        courseRegistrationDoc,
+        currentCard,
+        courseId,
+        cardId,
+        maxAttemptsPerView,
+        maxSessionViews,
+        sessionViews
+      );
+    }
+  }
+  /**
+   * Handles processing for correct responses: SRS scheduling and ELO updates.
+   */
+  processCorrectResponse(cardRecord, history, studySessionItem, courseRegistrationDoc, currentCard, courseId, cardId) {
+    if (cardRecord.priorAttemps === 0) {
+      void this.srsService.scheduleReview(history, studySessionItem);
+      if (history.records.length === 1) {
+        const userScore = 0.5 + cardRecord.performance / 2;
+        void this.eloService.updateUserAndCardElo(
+          userScore,
+          courseId,
+          cardId,
+          courseRegistrationDoc,
+          currentCard
+        );
+      } else {
+        const k = Math.ceil(32 / history.records.length);
+        const userScore = 0.5 + cardRecord.performance / 2;
+        void this.eloService.updateUserAndCardElo(
+          userScore,
+          courseId,
+          cardId,
+          courseRegistrationDoc,
+          currentCard,
+          k
+        );
+      }
+      logger.info(
+        "[ResponseProcessor] Processed correct response with SRS scheduling and ELO update"
+      );
+      return {
+        nextCardAction: "dismiss-success",
+        shouldLoadNextCard: true,
+        isCorrect: true,
+        performanceScore: cardRecord.performance,
+        shouldClearFeedbackShadow: true
+      };
+    } else {
+      logger.info(
+        "[ResponseProcessor] Processed correct response (retry attempt - no scheduling/ELO)"
+      );
+      return {
+        nextCardAction: "marked-failed",
+        shouldLoadNextCard: true,
+        isCorrect: true,
+        performanceScore: cardRecord.performance,
+        shouldClearFeedbackShadow: true
+      };
+    }
+  }
+  /**
+   * Handles processing for incorrect responses: ELO updates only.
+   */
+  processIncorrectResponse(cardRecord, history, courseRegistrationDoc, currentCard, courseId, cardId, maxAttemptsPerView, maxSessionViews, sessionViews) {
+    if (history.records.length !== 1 && cardRecord.priorAttemps === 0) {
+      void this.eloService.updateUserAndCardElo(
+        0,
+        // Failed response = 0 score
+        courseId,
+        cardId,
+        courseRegistrationDoc,
+        currentCard
+      );
+      logger.info("[ResponseProcessor] Processed incorrect response with ELO update");
+    } else {
+      logger.info("[ResponseProcessor] Processed incorrect response (no ELO update needed)");
+    }
+    if (currentCard.records.length >= maxAttemptsPerView) {
+      if (sessionViews >= maxSessionViews) {
+        void this.eloService.updateUserAndCardElo(
+          0,
+          courseId,
+          cardId,
+          courseRegistrationDoc,
+          currentCard
+        );
+        return {
+          nextCardAction: "dismiss-failed",
+          shouldLoadNextCard: true,
+          isCorrect: false,
+          shouldClearFeedbackShadow: true
+        };
+      } else {
+        return {
+          nextCardAction: "marked-failed",
+          shouldLoadNextCard: true,
+          isCorrect: false,
+          shouldClearFeedbackShadow: true
+        };
+      }
+    } else {
+      return {
+        nextCardAction: "none",
+        shouldLoadNextCard: false,
+        isCorrect: false,
+        shouldClearFeedbackShadow: true
+      };
+    }
+  }
+};
+
+// src/study/services/CardHydrationService.ts
+var import_common16 = require("@vue-skuilder/common");
+init_logger();
+
+// src/study/ItemQueue.ts
+var ItemQueue = class {
+  q = [];
+  seenCardIds = [];
+  _dequeueCount = 0;
+  get dequeueCount() {
+    return this._dequeueCount;
+  }
+  add(item, cardId) {
+    if (this.seenCardIds.find((d) => d === cardId)) {
+      return;
+    }
+    this.seenCardIds.push(cardId);
+    this.q.push(item);
+  }
+  addAll(items, cardIdExtractor) {
+    items.forEach((i) => this.add(i, cardIdExtractor(i)));
+  }
+  get length() {
+    return this.q.length;
+  }
+  peek(index) {
+    return this.q[index];
+  }
+  dequeue(cardIdExtractor) {
+    if (this.q.length !== 0) {
+      this._dequeueCount++;
+      const item = this.q.splice(0, 1)[0];
+      if (cardIdExtractor) {
+        const cardId = cardIdExtractor(item);
+        const index = this.seenCardIds.indexOf(cardId);
+        if (index > -1) {
+          this.seenCardIds.splice(index, 1);
+        }
+      }
+      return item;
+    } else {
+      return null;
+    }
+  }
+  get toString() {
+    return `${typeof this.q[0]}:
+` + this.q.map((i) => `	${i.courseID}+${i.cardID}: ${i.status}`).join("\n");
+  }
+};
+
+// src/study/services/CardHydrationService.ts
+var CardHydrationService = class {
+  constructor(getViewComponent, getCourseDB3, selectNextItemToHydrate, removeItemFromQueue, hasAvailableCards) {
+    this.getViewComponent = getViewComponent;
+    this.getCourseDB = getCourseDB3;
+    this.selectNextItemToHydrate = selectNextItemToHydrate;
+    this.removeItemFromQueue = removeItemFromQueue;
+    this.hasAvailableCards = hasAvailableCards;
+  }
+  hydratedQ = new ItemQueue();
+  failedCardCache = /* @__PURE__ */ new Map();
+  hydrationInProgress = false;
+  BUFFER_SIZE = 5;
+  /**
+   * Get the next hydrated card from the queue.
+   * @returns Hydrated card or null if none available
+   */
+  dequeueHydratedCard() {
+    return this.hydratedQ.dequeue((item) => item.item.cardID);
+  }
+  /**
+   * Check if hydration should be triggered and start background hydration if needed.
+   */
+  async ensureHydratedCards() {
+    if (this.hydratedQ.length < 3) {
+      void this.fillHydratedQueue();
+    }
+  }
+  /**
+   * Wait for a hydrated card to become available.
+   * @returns Promise that resolves to a hydrated card or null
+   */
+  async waitForHydratedCard() {
+    if (this.hydratedQ.length === 0 && this.hasAvailableCards()) {
+      void this.fillHydratedQueue();
+    }
+    while (this.hydratedQ.length === 0 && this.hasAvailableCards()) {
+      await new Promise((resolve) => setTimeout(resolve, 25));
+    }
+    return this.dequeueHydratedCard();
+  }
+  /**
+   * Get current hydrated queue length.
+   */
+  get hydratedCount() {
+    return this.hydratedQ.length;
+  }
+  /**
+   * Fill the hydrated queue up to BUFFER_SIZE with pre-fetched cards.
+   */
+  async fillHydratedQueue() {
+    if (this.hydrationInProgress) {
+      return;
+    }
+    this.hydrationInProgress = true;
+    try {
+      while (this.hydratedQ.length < this.BUFFER_SIZE) {
+        const nextItem = this.selectNextItemToHydrate();
+        if (!nextItem) {
+          return;
+        }
+        try {
+          if (this.failedCardCache.has(nextItem.cardID)) {
+            const cachedCard = this.failedCardCache.get(nextItem.cardID);
+            this.hydratedQ.add(cachedCard, cachedCard.item.cardID);
+            this.failedCardCache.delete(nextItem.cardID);
+          } else {
+            const courseDB = this.getCourseDB(nextItem.courseID);
+            const cardData = await courseDB.getCourseDoc(nextItem.cardID);
+            if (!(0, import_common16.isCourseElo)(cardData.elo)) {
+              cardData.elo = (0, import_common16.toCourseElo)(cardData.elo);
+            }
+            const view = this.getViewComponent(cardData.id_view);
+            const dataDocs = await Promise.all(
+              cardData.id_displayable_data.map(
+                (id) => courseDB.getCourseDoc(id, {
+                  attachments: true,
+                  binary: true
+                })
+              )
+            );
+            const data = dataDocs.map(import_common16.displayableDataToViewData).reverse();
+            this.hydratedQ.add(
+              {
+                item: nextItem,
+                view,
+                data
+              },
+              nextItem.cardID
+            );
+          }
+        } catch (e) {
+          logger.error(`Error hydrating card ${nextItem.cardID}:`, e);
+        } finally {
+          this.removeItemFromQueue(nextItem);
+        }
+      }
+    } finally {
+      this.hydrationInProgress = false;
+    }
+  }
+  /**
+   * Cache a failed card for quick re-access.
+   */
+  cacheFailedCard(card) {
+    this.failedCardCache.set(card.item.cardID, card);
+  }
+};
+
 // src/study/SessionController.ts
 init_couch();
 
@@ -5917,61 +6553,27 @@ init_dataDirectory();
 init_tuiLogger();
 
 // src/study/SessionController.ts
-var import_common15 = require("@vue-skuilder/common");
 function randomInt(min, max) {
   return Math.floor(Math.random() * (max - min + 1)) + min;
 }
-var ItemQueue = class {
-  q = [];
-  seenCardIds = [];
-  _dequeueCount = 0;
-  get dequeueCount() {
-    return this._dequeueCount;
-  }
-  add(item, cardId) {
-    if (this.seenCardIds.find((d) => d === cardId)) {
-      return;
-    }
-    this.seenCardIds.push(cardId);
-    this.q.push(item);
-  }
-  addAll(items, cardIdExtractor) {
-    items.forEach((i) => this.add(i, cardIdExtractor(i)));
-  }
-  get length() {
-    return this.q.length;
-  }
-  peek(index) {
-    return this.q[index];
-  }
-  dequeue() {
-    if (this.q.length !== 0) {
-      this._dequeueCount++;
-      return this.q.splice(0, 1)[0];
-    } else {
-      return null;
-    }
-  }
-  get toString() {
-    return `${typeof this.q[0]}:
-` + this.q.map((i) => `	${i.courseID}+${i.cardID}: ${i.status}`).join("\n");
-  }
-};
 var SessionController = class extends Loggable {
   _className = "SessionController";
+  services;
+  srsService;
+  eloService;
+  hydrationService;
   sources;
-  dataLayer;
-  getViewComponent;
+  // dataLayer and getViewComponent now injected into CardHydrationService
   _sessionRecord = [];
   set sessionRecord(r) {
     this._sessionRecord = r;
   }
+  // Session card stores
+  _currentCard = null;
   reviewQ = new ItemQueue();
   newQ = new ItemQueue();
   failedQ = new ItemQueue();
-  hydratedQ = new ItemQueue();
-  _currentCard = null;
-  hydration_in_progress = false;
+  // END   Session card stores
   startTime;
   endTime;
   _secondsRemaining;
@@ -5991,19 +6593,29 @@ var SessionController = class extends Loggable {
    */
   constructor(sources, time, dataLayer, getViewComponent) {
     super();
+    this.srsService = new SrsService(dataLayer.getUserDB());
+    this.eloService = new EloService(dataLayer, dataLayer.getUserDB());
+    this.hydrationService = new CardHydrationService(
+      getViewComponent,
+      (courseId) => dataLayer.getCourseDB(courseId),
+      () => this._selectNextItemToHydrate(),
+      (item) => this.removeItemFromQueue(item),
+      () => this.hasAvailableCards()
+    );
+    this.services = {
+      response: new ResponseProcessor(this.srsService, this.eloService)
+    };
     this.sources = sources;
     this.startTime = /* @__PURE__ */ new Date();
     this._secondsRemaining = time;
     this.endTime = new Date(this.startTime.valueOf() + 1e3 * this._secondsRemaining);
-    this.dataLayer = dataLayer;
-    this.getViewComponent = getViewComponent;
     this.log(`Session constructed:
     startTime: ${this.startTime}
     endTime: ${this.endTime}`);
   }
   tick() {
     this._secondsRemaining = Math.floor((this.endTime.valueOf() - Date.now()) / 1e3);
-    if (this._secondsRemaining === 0) {
+    if (this._secondsRemaining <= 0) {
       clearInterval(this._intervalHandle);
     }
   }
@@ -6047,7 +6659,7 @@ var SessionController = class extends Loggable {
     } catch (e) {
       this.error("Error preparing study session:", e);
     }
-    await this._fillHydratedQueue();
+    await this.hydrationService.ensureHydratedCards();
     this._intervalHandle = setInterval(() => {
       this.tick();
     }, 1e3);
@@ -6108,7 +6720,7 @@ var SessionController = class extends Loggable {
       }
     }
   }
-  _selectNextItemToHydrate(action = "dismiss-success") {
+  _selectNextItemToHydrate() {
     const choice = Math.random();
     let newBound = 0.1;
     let reviewBound = 0.75;
@@ -6141,9 +6753,6 @@ var SessionController = class extends Loggable {
       newBound = 0.01;
       reviewBound = 0.1;
     }
-    if (this.failedQ.length === 1 && action === "marked-failed") {
-      reviewBound = 1;
-    }
     if (this.failedQ.length === 0) {
       reviewBound = 1;
     }
@@ -6163,36 +6772,73 @@ var SessionController = class extends Loggable {
   }
   async nextCard(action = "dismiss-success") {
     this.dismissCurrentCard(action);
-    let card = this.hydratedQ.dequeue();
+    if (this._secondsRemaining <= 0 && this.failedQ.length === 0) {
+      this._currentCard = null;
+      return null;
+    }
+    let card = this.hydrationService.dequeueHydratedCard();
     if (!card && this.hasAvailableCards()) {
-      void this._fillHydratedQueue();
-      card = await this.nextHydratedCard();
+      card = await this.hydrationService.waitForHydratedCard();
     }
-    if (this.hydratedQ.length < 3) {
-      void this._fillHydratedQueue();
+    await this.hydrationService.ensureHydratedCards();
+    if (card) {
+      this._currentCard = card;
+    } else {
+      this._currentCard = null;
     }
     return card;
   }
+  /**
+   * Public API for processing user responses to cards.
+   * @param cardRecord User's response record
+   * @param cardHistory Promise resolving to the card's history
+   * @param courseRegistrationDoc User's course registration document
+   * @param currentCard Current study session record
+   * @param courseId Course identifier
+   * @param cardId Card identifier
+   * @param maxAttemptsPerView Maximum attempts allowed per view
+   * @param maxSessionViews Maximum session views for this card
+   * @param sessionViews Current number of session views
+   * @returns ResponseResult with navigation and UI instructions
+   */
+  async submitResponse(cardRecord, cardHistory, courseRegistrationDoc, currentCard, courseId, cardId, maxAttemptsPerView, maxSessionViews, sessionViews) {
+    const studySessionItem = {
+      ...currentCard.item
+    };
+    return await this.services.response.processResponse(
+      cardRecord,
+      cardHistory,
+      studySessionItem,
+      courseRegistrationDoc,
+      currentCard,
+      courseId,
+      cardId,
+      maxAttemptsPerView,
+      maxSessionViews,
+      sessionViews
+    );
+  }
   dismissCurrentCard(action = "dismiss-success") {
     if (this._currentCard) {
       if (action === "dismiss-success") {
       } else if (action === "marked-failed") {
+        this.hydrationService.cacheFailedCard(this._currentCard);
         let failedItem;
-        if (isReview(this._currentCard)) {
+        if (isReview(this._currentCard.item)) {
           failedItem = {
-            cardID: this._currentCard.cardID,
-            courseID: this._currentCard.courseID,
-            contentSourceID: this._currentCard.contentSourceID,
-            contentSourceType: this._currentCard.contentSourceType,
+            cardID: this._currentCard.item.cardID,
+            courseID: this._currentCard.item.courseID,
+            contentSourceID: this._currentCard.item.contentSourceID,
+            contentSourceType: this._currentCard.item.contentSourceType,
             status: "failed-review",
-            reviewID: this._currentCard.reviewID
+            reviewID: this._currentCard.item.reviewID
           };
         } else {
           failedItem = {
-            cardID: this._currentCard.cardID,
-            courseID: this._currentCard.courseID,
-            contentSourceID: this._currentCard.contentSourceID,
-            contentSourceType: this._currentCard.contentSourceType,
+            cardID: this._currentCard.item.cardID,
+            courseID: this._currentCard.item.courseID,
+            contentSourceID: this._currentCard.item.contentSourceID,
+            contentSourceType: this._currentCard.item.contentSourceType,
             status: "failed-new"
           };
         }
@@ -6205,141 +6851,19 @@ var SessionController = class extends Loggable {
   hasAvailableCards() {
     return this.reviewQ.length > 0 || this.newQ.length > 0 || this.failedQ.length > 0;
   }
-  async nextHydratedCard() {
-    while (this.hydratedQ.length === 0 && this.hasAvailableCards()) {
-      await new Promise((resolve) => setTimeout(resolve, 25));
-    }
-    return this.hydratedQ.dequeue();
-  }
-  async _fillHydratedQueue() {
-    if (this.hydration_in_progress) {
-      return;
-    }
-    const BUFFER_SIZE = 5;
-    this.hydration_in_progress = true;
-    while (this.hydratedQ.length < BUFFER_SIZE) {
-      const nextItem = this._selectNextItemToHydrate();
-      if (!nextItem) {
-        return;
-      }
-      try {
-        const cardData = await this.dataLayer.getCourseDB(nextItem.courseID).getCourseDoc(nextItem.cardID);
-        if (!(0, import_common15.isCourseElo)(cardData.elo)) {
-          cardData.elo = (0, import_common15.toCourseElo)(cardData.elo);
-        }
-        const view = this.getViewComponent(cardData.id_view);
-        const dataDocs = await Promise.all(
-          cardData.id_displayable_data.map(
-            (id) => this.dataLayer.getCourseDB(nextItem.courseID).getCourseDoc(id, {
-              attachments: true,
-              binary: true
-            })
-          )
-        );
-        const data = dataDocs.map(import_common15.displayableDataToViewData).reverse();
-        this.hydratedQ.add(
-          {
-            item: nextItem,
-            view,
-            data
-          },
-          nextItem.cardID
-        );
-        if (this.reviewQ.peek(0) === nextItem) {
-          this.reviewQ.dequeue();
-        } else if (this.newQ.peek(0) === nextItem) {
-          this.newQ.dequeue();
-        } else {
-          this.failedQ.dequeue();
-        }
-      } catch (e) {
-        this.error(`Error hydrating card ${nextItem.cardID}:`, e);
-        if (this.reviewQ.peek(0) === nextItem) {
-          this.reviewQ.dequeue();
-        } else if (this.newQ.peek(0) === nextItem) {
-          this.newQ.dequeue();
-        } else {
-          this.failedQ.dequeue();
-        }
-      }
-    }
-    this.hydration_in_progress = false;
-  }
-};
-
-// src/study/SpacedRepetition.ts
-init_util();
-var import_moment6 = __toESM(require("moment"));
-init_logger();
-var duration = import_moment6.default.duration;
-function newInterval(user, cardHistory) {
-  if (areQuestionRecords(cardHistory)) {
-    return newQuestionInterval(user, cardHistory);
-  } else {
-    return 1e5;
-  }
-}
-function newQuestionInterval(user, cardHistory) {
-  const records = cardHistory.records;
-  const currentAttempt = records[records.length - 1];
-  const lastInterval = lastSuccessfulInterval(records);
-  if (lastInterval > cardHistory.bestInterval) {
-    cardHistory.bestInterval = lastInterval;
-    void user.update(cardHistory._id, {
-      bestInterval: lastInterval
-    });
-  }
-  if (currentAttempt.isCorrect) {
-    const skill = Math.min(1, Math.max(0, currentAttempt.performance));
-    logger.debug(`Demontrated skill: 	${skill}`);
-    const interval = lastInterval * (0.75 + skill);
-    cardHistory.lapses = getLapses(cardHistory.records);
-    cardHistory.streak = getStreak(cardHistory.records);
-    if (cardHistory.lapses && cardHistory.streak && cardHistory.bestInterval && (cardHistory.lapses >= 0 || cardHistory.streak >= 0)) {
-      const ret = (cardHistory.lapses * interval + cardHistory.streak * cardHistory.bestInterval) / (cardHistory.lapses + cardHistory.streak);
-      logger.debug(`Weighted average interval calculation:
-	(${cardHistory.lapses} * ${interval} + ${cardHistory.streak} * ${cardHistory.bestInterval}) / (${cardHistory.lapses} + ${cardHistory.streak}) = ${ret}`);
-      return ret;
+  /**
+   * Helper method for CardHydrationService to remove items from appropriate queue.
+   */
+  removeItemFromQueue(item) {
+    if (this.reviewQ.peek(0) === item) {
+      this.reviewQ.dequeue((queueItem) => queueItem.cardID);
+    } else if (this.newQ.peek(0) === item) {
+      this.newQ.dequeue((queueItem) => queueItem.cardID);
     } else {
-      return interval;
+      this.failedQ.dequeue((queueItem) => queueItem.cardID);
     }
-  } else {
-    return 0;
   }
-}
-function lastSuccessfulInterval(cardHistory) {
-  for (let i = cardHistory.length - 1; i >= 1; i--) {
-    if (cardHistory[i].priorAttemps === 0 && cardHistory[i].isCorrect) {
-      const lastInterval = secondsBetween(cardHistory[i - 1].timeStamp, cardHistory[i].timeStamp);
-      const ret = Math.max(lastInterval, 20 * 60 * 60);
-      logger.debug(`Last interval w/ this card was: ${lastInterval}s, returning ${ret}s`);
-      return ret;
-    }
-  }
-  return getInitialInterval(cardHistory);
-}
-function getStreak(records) {
-  let streak = 0;
-  let index = records.length - 1;
-  while (index >= 0 && records[index].isCorrect) {
-    index--;
-    streak++;
-  }
-  return streak;
-}
-function getLapses(records) {
-  return records.filter((r) => r.isCorrect === false).length;
-}
-function getInitialInterval(cardHistory) {
-  logger.warn(`history of length: ${cardHistory.length} ignored!`);
-  return 60 * 60 * 24 * 3;
-}
-function secondsBetween(start, end) {
-  start = (0, import_moment6.default)(start);
-  end = (0, import_moment6.default)(end);
-  const ret = duration(end.diff(start)).asSeconds();
-  return ret;
-}
+};
 
 // src/index.ts
 init_factory();