@vue-skuilder/db 0.1.11-9 → 0.1.12

package/dist/index.js

@@ -187,9 +187,9 @@ var init_pouchdb_setup = __esm({
     import_pouchdb.default.plugin(import_pouchdb_find.default);
     import_pouchdb.default.plugin(import_pouchdb_authentication.default);
     import_pouchdb.default.defaults({
-      ajax: {
-        timeout: 6e4
-      }
+      // ajax: {
+      //   timeout: 60000,
+      // },
     });
     pouchdb_setup_default = import_pouchdb.default;
   }
@@ -468,42 +468,58 @@ 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) {
             this.inprogressUpdates[id] = true;
-            try {
-              let doc = await this.readDB.get(id);
-              logger.debug(`Retrieved doc: ${id}`);
-              while (this.pendingUpdates[id].length !== 0) {
-                const update = this.pendingUpdates[id].splice(0, 1)[0];
-                if (typeof update === "function") {
-                  doc = { ...doc, ...update(doc) };
+            const MAX_RETRIES = 5;
+            for (let i = 0; i < MAX_RETRIES; i++) {
+              try {
+                const doc = await this.readDB.get(id);
+                logger.debug(`Retrieved doc: ${id}`);
+                let updatedDoc = { ...doc };
+                const updatesToApply = [...this.pendingUpdates[id]];
+                for (const update of updatesToApply) {
+                  if (typeof update === "function") {
+                    updatedDoc = { ...updatedDoc, ...update(updatedDoc) };
+                  } else {
+                    updatedDoc = {
+                      ...updatedDoc,
+                      ...update
+                    };
+                  }
+                }
+                await this.writeDB.put(updatedDoc);
+                logger.debug(`Put doc: ${id}`);
+                this.pendingUpdates[id].splice(0, updatesToApply.length);
+                if (this.pendingUpdates[id].length === 0) {
+                  this.inprogressUpdates[id] = false;
+                  delete this.inprogressUpdates[id];
                 } else {
-                  doc = {
-                    ...doc,
-                    ...update
-                  };
+                  return this.applyUpdates(id);
+                }
+                return updatedDoc;
+              } catch (e) {
+                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]) {
+                    delete this.pendingUpdates[id];
+                  }
+                  logger.error(`Error on attemped update (retry ${i}): ${JSON.stringify(e)}`);
+                  throw e;
                 }
               }
-              await this.writeDB.put(doc);
-              logger.debug(`Put doc: ${id}`);
-              if (this.pendingUpdates[id].length === 0) {
-                this.inprogressUpdates[id] = false;
-                delete this.inprogressUpdates[id];
-              } else {
-                return this.applyUpdates(id);
-              }
-              return doc;
-            } catch (e) {
-              delete this.inprogressUpdates[id];
-              if (this.pendingUpdates[id]) {
-                delete this.pendingUpdates[id];
-              }
-              logger.error(`Error on attemped update: ${JSON.stringify(e)}`);
-              throw e;
             }
+            throw new Error(`UpdateQueue failed for doc ${id} after ${MAX_RETRIES} retries.`);
           } else {
             throw new Error(`Empty Updates Queue Triggered`);
           }
@@ -754,7 +770,7 @@ function getCourseDB(courseID) {
   const dbName = `coursedb-${courseID}`;
   return new pouchdb_setup_default(
     ENV.COUCHDB_SERVER_PROTOCOL + "://" + ENV.COUCHDB_SERVER_URL + dbName,
-    pouchDBincludeCredentialsConfig
+    createPouchDBConfig()
   );
 }
 var import_common, import_common2, import_common3, import_uuid, AlreadyTaggedErr;
@@ -880,6 +896,7 @@ var init_courseLookupDB = __esm({
         const doc = await _CourseLookup._db.get(courseID);
         return await _CourseLookup._db.remove(doc);
       }
+      // [ ] rename to allCourses()
       static async allCourseWare() {
         const resp = await _CourseLookup._db.allDocs({
           include_docs: true
@@ -950,13 +967,16 @@ var init_elo = __esm({
       }
       async getNewCards(limit = 99) {
         const activeCards = await this.user.getActiveCards();
-        return (await this.course.getCardsCenteredAtELO({ limit, elo: "user" }, (c) => {
-          if (activeCards.some((ac) => c.includes(ac))) {
-            return false;
-          } else {
-            return true;
+        return (await this.course.getCardsCenteredAtELO(
+          { limit, elo: "user" },
+          (c) => {
+            if (activeCards.some((ac) => c.cardID === ac.cardID)) {
+              return false;
+            } else {
+              return true;
+            }
           }
-        })).map((c) => {
+        )).map((c) => {
           return {
             ...c,
             status: "new"
@@ -967,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))
     });
   }
@@ -992,6 +1074,7 @@ var init_navigators = __esm({
     init_();
     Navigators = /* @__PURE__ */ ((Navigators2) => {
       Navigators2["ELO"] = "elo";
+      Navigators2["HARDCODED"] = "hardcodedOrder";
       return Navigators2;
     })(Navigators || {});
     ContentNavigator = class {
@@ -1004,7 +1087,7 @@ var init_navigators = __esm({
       static async create(user, course, strategyData) {
         const implementingClass = strategyData.implementingClass;
         let NavigatorImpl;
-        const variations = ["", ".js", ".ts"];
+        const variations = [".ts", ".js", ""];
         for (const ext of variations) {
           try {
             const module2 = await globImport(`./${implementingClass}${ext}`);
@@ -1261,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) {
@@ -1308,7 +1408,13 @@ var init_courseDB = __esm({
           } else {
             return s;
           }
-        }).map((c) => `${this.id}-${c.id}-${c.key}`);
+        }).map((c) => {
+          return {
+            courseID: this.id,
+            cardID: c.id,
+            elo: c.key
+          };
+        });
         const str = `below:
 ${below.rows.map((r) => `	${r.id}-${r.key}
 `)}
@@ -1363,7 +1469,13 @@ ${above.rows.map((r) => `	${r.id}-${r.key}
         }
       }
       async addTagToCard(cardId, tagId, updateELO) {
-        return await addTagToCard(this.id, cardId, tagId, (await this._getCurrentUser()).getUsername(), updateELO);
+        return await addTagToCard(
+          this.id,
+          cardId,
+          tagId,
+          (await this._getCurrentUser()).getUsername(),
+          updateELO
+        );
       }
       async removeTagFromCard(cardId, tagId) {
         return await removeTagFromCard(this.id, cardId, tagId);
@@ -1432,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",
@@ -1456,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}`);
@@ -1471,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",
@@ -1556,17 +1688,93 @@ ${above.rows.map((r) => `	${r.id}-${r.key}
           selectedCards.push(card);
         }
         return selectedCards.map((c) => {
-          const split = c.split("-");
           return {
             courseID: this.id,
-            cardID: split[1],
-            qualifiedID: `${split[0]}-${split[1]}`,
+            cardID: c.cardID,
             contentSourceType: "course",
             contentSourceID: this.id,
+            elo: c.elo,
             status: "new"
           };
         });
       }
+      // Admin search methods
+      async searchCards(query) {
+        logger.log(`[CourseDB ${this.id}] Searching for: "${query}"`);
+        let displayableData;
+        try {
+          displayableData = await this.db.find({
+            selector: {
+              docType: "DISPLAYABLE_DATA",
+              "data.0.data": { $regex: `.*${query}.*` }
+            }
+          });
+          logger.log(`[CourseDB ${this.id}] Regex search on data[0].data successful`);
+        } catch (regexError) {
+          logger.log(
+            `[CourseDB ${this.id}] Regex search failed, falling back to manual search:`,
+            regexError
+          );
+          const allDisplayable = await this.db.find({
+            selector: {
+              docType: "DISPLAYABLE_DATA"
+            }
+          });
+          logger.log(
+            `[CourseDB ${this.id}] Retrieved ${allDisplayable.docs.length} documents for manual filtering`
+          );
+          displayableData = {
+            docs: allDisplayable.docs.filter((doc) => {
+              const docString = JSON.stringify(doc).toLowerCase();
+              const match = docString.includes(query.toLowerCase());
+              if (match) {
+                logger.log(`[CourseDB ${this.id}] Manual match found in document: ${doc._id}`);
+              }
+              return match;
+            })
+          };
+        }
+        logger.log(
+          `[CourseDB ${this.id}] Found ${displayableData.docs.length} displayable data documents`
+        );
+        if (displayableData.docs.length === 0) {
+          const allDisplayableData = await this.db.find({
+            selector: {
+              docType: "DISPLAYABLE_DATA"
+            },
+            limit: 5
+            // Just sample a few
+          });
+          logger.log(
+            `[CourseDB ${this.id}] Sample displayable data:`,
+            allDisplayableData.docs.map((d) => ({
+              id: d._id,
+              docType: d.docType,
+              dataStructure: d.data ? Object.keys(d.data) : "no data field",
+              dataContent: d.data,
+              fullDoc: d
+            }))
+          );
+        }
+        const allResults = [];
+        for (const dd of displayableData.docs) {
+          const cards = await this.db.find({
+            selector: {
+              docType: "CARD",
+              id_displayable_data: { $in: [dd._id] }
+            }
+          });
+          logger.log(
+            `[CourseDB ${this.id}] Displayable data ${dd._id} linked to ${cards.docs.length} cards`
+          );
+          allResults.push(...cards.docs);
+        }
+        logger.log(`[CourseDB ${this.id}] Total cards found: ${allResults.length}`);
+        return allResults;
+      }
+      async find(request) {
+        return this.db.find(request);
+      }
     };
   }
 });
@@ -1632,7 +1840,7 @@ var init_classroomDB2 = __esm({
         const dbName = `classdb-student-${this._id}`;
         this._db = new pouchdb_setup_default(
           ENV.COUCHDB_SERVER_PROTOCOL + "://" + ENV.COUCHDB_SERVER_URL + dbName,
-          pouchDBincludeCredentialsConfig
+          createPouchDBConfig()
         );
         try {
           const cfg = await this._db.get(CLASSROOM_CONFIG);
@@ -1701,9 +1909,11 @@ var init_classroomDB2 = __esm({
             ret.push(await getCourseDB2(content.courseID).get(content.cardID));
           }
         }
-        logger.info(`New Cards from classroom ${this._cfg.name}: ${ret.map((c) => c.qualifiedID)}`);
+        logger.info(
+          `New Cards from classroom ${this._cfg.name}: ${ret.map((c) => `${c.courseID}-${c.cardID}`)}`
+        );
         return ret.filter((c) => {
-          if (activeCards.some((ac) => c.qualifiedID.includes(ac))) {
+          if (activeCards.some((ac) => c.cardID === ac.cardID)) {
             return false;
           } else {
             return true;
@@ -1722,11 +1932,11 @@ var init_classroomDB2 = __esm({
         const stuDbName = `classdb-student-${this._id}`;
         this._db = new pouchdb_setup_default(
           ENV.COUCHDB_SERVER_PROTOCOL + "://" + ENV.COUCHDB_SERVER_URL + dbName,
-          pouchDBincludeCredentialsConfig
+          createPouchDBConfig()
         );
         this._stuDb = new pouchdb_setup_default(
           ENV.COUCHDB_SERVER_PROTOCOL + "://" + ENV.COUCHDB_SERVER_URL + stuDbName,
-          pouchDBincludeCredentialsConfig
+          createPouchDBConfig()
         );
         try {
           return this._db.get(CLASSROOM_CONFIG).then((cfg) => {
@@ -1811,7 +2021,7 @@ var init_adminDB2 = __esm({
       constructor() {
         this.usersDB = new pouchdb_setup_default(
           ENV.COUCHDB_SERVER_PROTOCOL + "://" + ENV.COUCHDB_SERVER_URL + "_users",
-          pouchDBincludeCredentialsConfig
+          createPouchDBConfig()
         );
       }
       async getUsers() {
@@ -1872,9 +2082,10 @@ var init_adminDB2 = __esm({
 async function getCurrentSession() {
   try {
     if (ENV.COUCHDB_SERVER_URL === NOT_SET || ENV.COUCHDB_SERVER_PROTOCOL === NOT_SET) {
-      throw new Error("CouchDB server configuration not properly initialized");
+      throw new Error(`CouchDB server configuration not properly initialized. Protocol: "${ENV.COUCHDB_SERVER_PROTOCOL}", URL: "${ENV.COUCHDB_SERVER_URL}"`);
     }
-    const url = `${ENV.COUCHDB_SERVER_PROTOCOL}://${ENV.COUCHDB_SERVER_URL}_session`;
+    const baseUrl = ENV.COUCHDB_SERVER_URL.endsWith("/") ? ENV.COUCHDB_SERVER_URL.slice(0, -1) : ENV.COUCHDB_SERVER_URL;
+    const url = `${ENV.COUCHDB_SERVER_PROTOCOL}://${baseUrl}/_session`;
     logger.debug(`Attempting session check at: ${url}`);
     const response = await (0, import_cross_fetch.default)(url, {
       method: "GET",
@@ -1886,8 +2097,10 @@ async function getCurrentSession() {
     const resp = await response.json();
     return resp;
   } catch (error) {
-    logger.error(`Session check error: ${error}`);
-    throw new Error(`Session check failed: ${error}`);
+    const baseUrl = ENV.COUCHDB_SERVER_URL.endsWith("/") ? ENV.COUCHDB_SERVER_URL.slice(0, -1) : ENV.COUCHDB_SERVER_URL;
+    const url = `${ENV.COUCHDB_SERVER_PROTOCOL}://${baseUrl}/_session`;
+    logger.error(`Session check error attempting to connect to: ${url} - ${error}`);
+    throw new Error(`Session check failed connecting to ${url}: ${error}`);
   }
 }
 async function getLoggedInUsername() {
@@ -2082,7 +2295,7 @@ var init_CouchDBSyncStrategy = __esm({
         log3(`Fetching user database: ${dbName} (${username})`);
         const ret = new pouchdb_setup_default(
           ENV.COUCHDB_SERVER_PROTOCOL + "://" + ENV.COUCHDB_SERVER_URL + dbName,
-          pouchDBincludeCredentialsConfig
+          createPouchDBConfig()
         );
         if (guestAccount) {
           updateGuestAccountExpirationDate(ret);
@@ -2094,10 +2307,29 @@ var init_CouchDBSyncStrategy = __esm({
 });
 
 // src/impl/couch/index.ts
+function createPouchDBConfig() {
+  const hasExplicitCredentials = ENV.COUCHDB_USERNAME && ENV.COUCHDB_PASSWORD;
+  const isNodeEnvironment2 = typeof window === "undefined";
+  if (hasExplicitCredentials && isNodeEnvironment2) {
+    return {
+      fetch(url, opts = {}) {
+        const basicAuth = btoa(`${ENV.COUCHDB_USERNAME}:${ENV.COUCHDB_PASSWORD}`);
+        const headers = new Headers(opts.headers || {});
+        headers.set("Authorization", `Basic ${basicAuth}`);
+        const newOpts = {
+          ...opts,
+          headers
+        };
+        return pouchdb_setup_default.fetch(url, newOpts);
+      }
+    };
+  }
+  return pouchDBincludeCredentialsConfig;
+}
 function getCourseDB2(courseID) {
   return new pouchdb_setup_default(
     ENV.COUCHDB_SERVER_PROTOCOL + "://" + ENV.COUCHDB_SERVER_URL + "coursedb-" + courseID,
-    pouchDBincludeCredentialsConfig
+    createPouchDBConfig()
   );
 }
 function getCourseDocs(courseID, docIDs, options = {}) {
@@ -2389,6 +2621,9 @@ Currently logged-in as ${this._username}.`
         await this.init();
         return ret;
       }
+      async get(id) {
+        return this.localDB.get(id);
+      }
       update(id, update) {
         return this.updateQueue.update(id, update);
       }
@@ -2435,7 +2670,12 @@ Currently logged-in as ${this._username}.`
           endkey: keys.endkey,
           include_docs: true
         });
-        return reviews.rows.map((r) => `${r.doc.courseId}-${r.doc.cardId}`);
+        return reviews.rows.map((r) => {
+          return {
+            courseID: r.doc.courseId,
+            cardID: r.doc.cardId
+          };
+        });
       }
       async getActivityRecords() {
         try {
@@ -2715,8 +2955,18 @@ Currently logged-in as ${this._username}.`
         }
         this.setDBandQ();
         this.syncStrategy.startSync(this.localDB, this.remoteDB);
-        void this.applyDesignDocs();
-        void this.deduplicateReviews();
+        this.applyDesignDocs().catch((error) => {
+          log4(`Error in applyDesignDocs background task: ${error}`);
+          if (error && typeof error === "object") {
+            log4(`Full error details in applyDesignDocs: ${JSON.stringify(error)}`);
+          }
+        });
+        this.deduplicateReviews().catch((error) => {
+          log4(`Error in deduplicateReviews background task: ${error}`);
+          if (error && typeof error === "object") {
+            log4(`Full error details in background task: ${JSON.stringify(error)}`);
+          }
+        });
         _BaseUser._initialized = true;
       }
       static designDocs = [
@@ -2734,10 +2984,15 @@ Currently logged-in as ${this._username}.`
         }
       ];
       async applyDesignDocs() {
+        log4(`Starting applyDesignDocs for user: ${this._username}`);
+        log4(`Remote DB name: ${this.remoteDB.name || "unknown"}`);
         if (this._username === "admin") {
+          log4("Skipping design docs for admin user");
           return;
         }
+        log4(`Applying ${_BaseUser.designDocs.length} design docs`);
         for (const doc of _BaseUser.designDocs) {
+          log4(`Applying design doc: ${doc._id}`);
           try {
             try {
               const existingDoc = await this.remoteDB.get(doc._id);
@@ -2814,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}
@@ -2836,8 +3095,13 @@ Currently logged-in as ${this._username}.`
       async deduplicateReviews() {
         try {
           log4("Starting deduplication of scheduled reviews...");
+          log4(`Remote DB name: ${this.remoteDB.name || "unknown"}`);
+          log4(`Write DB name: ${this.writeDB.name || "unknown"}`);
           const reviewsMap = {};
           const duplicateDocIds = [];
+          log4(
+            `Attempting to query remoteDB for reviewCards/reviewCards. Database: ${this.remoteDB.name || "unknown"}`
+          );
           const scheduledReviews = await this.remoteDB.query("reviewCards/reviewCards");
           log4(`Found ${scheduledReviews.rows.length} scheduled reviews to process`);
           scheduledReviews.rows.forEach((r) => {
@@ -2872,6 +3136,17 @@ Currently logged-in as ${this._username}.`
           }
         } catch (error) {
           log4(`Error during review deduplication: ${error}`);
+          if (error && typeof error === "object" && "status" in error && error.status === 404) {
+            log4(
+              `Database not found (404) during review deduplication. Database: ${this.remoteDB.name || "unknown"}`
+            );
+            log4(
+              `This might indicate the user database doesn't exist or the reviewCards view isn't available`
+            );
+          }
+          if (error && typeof error === "object") {
+            log4(`Full error details: ${JSON.stringify(error)}`);
+          }
         }
       }
       /**
@@ -3105,6 +3380,16 @@ var init_PouchDataLayerProvider = __esm({
       getAdminDB() {
         return new AdminDB();
       }
+      async createUserReaderForUser(targetUsername) {
+        const requestingUsername = await getLoggedInUsername();
+        if (requestingUsername !== "admin") {
+          throw new Error("Unauthorized: Only admin users can access other users' data");
+        }
+        logger.info(`Admin user '${requestingUsername}' requesting UserDBReader for '${targetUsername}'`);
+        const syncStrategy = new CouchDBSyncStrategy();
+        const targetUserDB = await BaseUser.instance(syncStrategy, targetUsername);
+        return targetUserDB;
+      }
       isReadOnly() {
         return false;
       }
@@ -3557,7 +3842,10 @@ var init_courseDB2 = __esm({
         };
       }
       async getCardsByELO(elo, limit) {
-        return this.unpacker.queryByElo(elo, limit || 25);
+        return (await this.unpacker.queryByElo(elo, limit || 25)).map((card) => {
+          const [courseID, cardID, elo2] = card.split("-");
+          return { courseID, cardID, elo: elo2 ? parseInt(elo2) : void 0 };
+        });
       }
       async getCardEloData(cardIds) {
         const results = await Promise.all(
@@ -3575,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;
@@ -3601,14 +3893,19 @@ var init_courseDB2 = __esm({
         } else if (options.elo === "random") {
           targetElo = 800 + Math.random() * 400;
         }
-        let cardIds = await this.unpacker.queryByElo(targetElo, options.limit * 2);
+        let cardIds = (await this.unpacker.queryByElo(targetElo, options.limit * 2)).map((c) => {
+          return {
+            cardID: c,
+            courseID: this.courseId
+          };
+        });
         if (filter) {
           cardIds = cardIds.filter(filter);
         }
-        return cardIds.slice(0, options.limit).map((cardId) => ({
+        return cardIds.slice(0, options.limit).map((card) => ({
           status: "new",
-          qualifiedID: `${this.courseId}-${cardId}`,
-          cardID: cardId,
+          // qualifiedID: `${this.courseId}-${cardId}`,
+          cardID: card.cardID,
           contentSourceType: "course",
           contentSourceID: this.courseId,
           courseID: this.courseId
@@ -3760,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",
@@ -3800,6 +4097,16 @@ var init_courseDB2 = __esm({
       async getAttachmentBlob(docId, attachmentName) {
         return this.unpacker.getAttachmentBlob(docId, attachmentName);
       }
+      // Admin search methods
+      async searchCards(_query) {
+        return [];
+      }
+      async find(_request) {
+        return {
+          docs: [],
+          warning: "Find operations not supported in static mode"
+        };
+      }
     };
   }
 });
@@ -3815,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(
@@ -3911,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() {
@@ -3941,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");
@@ -3955,6 +4294,12 @@ var init_StaticDataLayerProvider = __esm({
       getAdminDB() {
         throw new Error("Admin functions not supported in static mode");
       }
+      async createUserReaderForUser(targetUsername) {
+        logger.warn(`StaticDataLayerProvider: Multi-user access not supported in static mode`);
+        logger.warn(`Request: trying to access data for ${targetUsername}`);
+        logger.warn(`Returning current user's data instead`);
+        return this.getUserDB();
+      }
       isReadOnly() {
         return true;
       }
@@ -4290,66 +4635,557 @@ module.exports = __toCommonJS(index_exports);
 init_core();
 init_courseLookupDB();
 
-// src/study/SessionController.ts
+// src/study/services/SrsService.ts
+var import_moment7 = __toESM(require("moment"));
 init_couch();
 
-// src/util/index.ts
-init_Loggable();
-
-// src/util/packer/CouchDBToStaticPacker.ts
-init_types_legacy();
+// src/study/SpacedRepetition.ts
+init_util();
+var import_moment6 = __toESM(require("moment"));
 init_logger();
-var CouchDBToStaticPacker = class {
-  config;
-  sourceDB = null;
-  constructor(config = {}) {
-    this.config = {
-      chunkSize: 1e3,
-      includeAttachments: true,
-      ...config
-    };
-  }
-  /**
-   * Pack a CouchDB course database into static data structures
-   */
-  async packCourse(sourceDB, courseId) {
-    logger.info(`Starting static pack for course: ${courseId}`);
-    this.sourceDB = sourceDB;
-    const manifest = {
-      version: "1.0.0",
-      courseId,
-      courseName: "",
-      courseConfig: null,
-      lastUpdated: (/* @__PURE__ */ new Date()).toISOString(),
-      documentCount: 0,
-      chunks: [],
-      indices: [],
-      designDocs: []
-    };
-    const courseConfig = await this.extractCourseConfig(sourceDB);
-    manifest.courseName = courseConfig.name;
-    manifest.courseConfig = courseConfig;
-    manifest.designDocs = await this.extractDesignDocs(sourceDB);
-    const docsByType = await this.extractDocumentsByType(sourceDB);
-    const attachments = /* @__PURE__ */ new Map();
-    if (this.config.includeAttachments) {
-      await this.extractAllAttachments(docsByType, attachments);
-    }
-    const chunks = /* @__PURE__ */ new Map();
-    for (const [docType, docs] of Object.entries(docsByType)) {
-      const chunkMetadata = this.createChunks(docs, docType);
-      manifest.chunks.push(...chunkMetadata);
-      manifest.documentCount += docs.length;
-      this.prepareChunkData(chunkMetadata, docs, chunks);
-    }
-    const indices = /* @__PURE__ */ new Map();
-    manifest.indices = await this.buildIndices(docsByType, manifest.designDocs, indices);
-    return {
-      manifest,
-      chunks,
-      indices,
-      attachments
-    };
+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();
+
+// src/util/index.ts
+init_Loggable();
+
+// src/util/packer/CouchDBToStaticPacker.ts
+init_types_legacy();
+init_logger();
+var CouchDBToStaticPacker = class {
+  config;
+  sourceDB = null;
+  constructor(config = {}) {
+    this.config = {
+      chunkSize: 1e3,
+      includeAttachments: true,
+      ...config
+    };
+  }
+  /**
+   * Pack a CouchDB course database into static data structures
+   */
+  async packCourse(sourceDB, courseId) {
+    logger.info(`Starting static pack for course: ${courseId}`);
+    this.sourceDB = sourceDB;
+    const manifest = {
+      version: "1.0.0",
+      courseId,
+      courseName: "",
+      courseConfig: null,
+      lastUpdated: (/* @__PURE__ */ new Date()).toISOString(),
+      documentCount: 0,
+      chunks: [],
+      indices: [],
+      designDocs: []
+    };
+    const courseConfig = await this.extractCourseConfig(sourceDB);
+    manifest.courseName = courseConfig.name;
+    manifest.courseConfig = courseConfig;
+    manifest.designDocs = await this.extractDesignDocs(sourceDB);
+    const docsByType = await this.extractDocumentsByType(sourceDB);
+    const attachments = /* @__PURE__ */ new Map();
+    if (this.config.includeAttachments) {
+      await this.extractAllAttachments(docsByType, attachments);
+    }
+    const chunks = /* @__PURE__ */ new Map();
+    for (const [docType, docs] of Object.entries(docsByType)) {
+      const chunkMetadata = this.createChunks(docs, docType);
+      manifest.chunks.push(...chunkMetadata);
+      manifest.documentCount += docs.length;
+      this.prepareChunkData(chunkMetadata, docs, chunks);
+    }
+    const indices = /* @__PURE__ */ new Map();
+    manifest.indices = await this.buildIndices(docsByType, manifest.designDocs, indices);
+    return {
+      manifest,
+      chunks,
+      indices,
+      attachments
+    };
   }
   /**
    * Pack a CouchDB course database and write the static files to disk
@@ -5720,58 +6556,24 @@ init_tuiLogger();
 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) {
-    if (this.seenCardIds.find((d) => d === item.cardID)) {
-      return;
-    }
-    this.seenCardIds.push(item.cardID);
-    this.q.push(item);
-  }
-  addAll(items) {
-    items.forEach((i) => this.add(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.qualifiedID}: ${i.status}`).join("\n");
-  }
-};
 var SessionController = class extends Loggable {
   _className = "SessionController";
+  services;
+  srsService;
+  eloService;
+  hydrationService;
   sources;
+  // 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();
-  _currentCard = null;
-  /**
-   * Indicates whether the session has been initialized - eg, the
-   * queues have been populated.
-   */
-  _isInitialized = false;
+  // END   Session card stores
   startTime;
   endTime;
   _secondsRemaining;
@@ -5789,8 +6591,20 @@ var SessionController = class extends Loggable {
   /**
    *
    */
-  constructor(sources, time) {
+  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;
@@ -5801,7 +6615,7 @@ var SessionController = class extends Loggable {
   }
   tick() {
     this._secondsRemaining = Math.floor((this.endTime.valueOf() - Date.now()) / 1e3);
-    if (this._secondsRemaining === 0) {
+    if (this._secondsRemaining <= 0) {
       clearInterval(this._intervalHandle);
     }
   }
@@ -5845,7 +6659,7 @@ var SessionController = class extends Loggable {
     } catch (e) {
       this.error("Error preparing study session:", e);
     }
-    this._isInitialized = true;
+    await this.hydrationService.ensureHydratedCards();
     this._intervalHandle = setInterval(() => {
       this.tick();
     }, 1e3);
@@ -5883,12 +6697,8 @@ var SessionController = class extends Loggable {
       }
     }
     let report = "Review session created with:\n";
-    for (let i = 0; i < dueCards.length; i++) {
-      const card = dueCards[i];
-      this.reviewQ.add(card);
-      report += `	${card.qualifiedID}}
-`;
-    }
+    this.reviewQ.addAll(dueCards, (c) => c.cardID);
+    report += dueCards.map((card) => `Card ${card.courseID}::${card.cardID} `).join("\n");
     this.log(report);
   }
   async getNewCards(n = 10) {
@@ -5903,36 +6713,32 @@ var SessionController = class extends Loggable {
       for (let i = 0; i < newContent.length; i++) {
         if (newContent[i].length > 0) {
           const item = newContent[i].splice(0, 1)[0];
-          this.log(`Adding new card: ${item.qualifiedID}`);
-          this.newQ.add(item);
+          this.log(`Adding new card: ${item.courseID}::${item.cardID}`);
+          this.newQ.add(item, item.cardID);
           n--;
         }
       }
     }
   }
-  nextNewCard() {
-    const item = this.newQ.dequeue();
-    if (this._isInitialized && this.newQ.length < 5) {
-      void this.getNewCards();
-    }
-    return item;
-  }
-  nextCard(action = "dismiss-success") {
-    this.dismissCurrentCard(action);
+  _selectNextItemToHydrate() {
     const choice = Math.random();
     let newBound = 0.1;
     let reviewBound = 0.75;
     if (this.reviewQ.length === 0 && this.failedQ.length === 0 && this.newQ.length === 0) {
-      this._currentCard = null;
-      return this._currentCard;
+      return null;
     }
     if (this._secondsRemaining < 2 && this.failedQ.length === 0) {
-      this._currentCard = null;
-      return this._currentCard;
+      return null;
+    }
+    if (this._secondsRemaining <= 0) {
+      if (this.failedQ.length > 0) {
+        return this.failedQ.peek(0);
+      } else {
+        return null;
+      }
     }
     if (this.newQ.dequeueCount < this.sources.length && this.newQ.length) {
-      this._currentCard = this.nextNewCard();
-      return this._currentCard;
+      return this.newQ.peek(0);
     }
     const cleanupTime = this.estimateCleanupTime();
     const reviewTime = this.estimateReviewTime();
@@ -5947,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;
     }
@@ -5957,123 +6760,110 @@ var SessionController = class extends Loggable {
       newBound = reviewBound;
     }
     if (choice < newBound && this.newQ.length) {
-      this._currentCard = this.nextNewCard();
+      return this.newQ.peek(0);
     } else if (choice < reviewBound && this.reviewQ.length) {
-      this._currentCard = this.reviewQ.dequeue();
+      return this.reviewQ.peek(0);
     } else if (this.failedQ.length) {
-      this._currentCard = this.failedQ.dequeue();
+      return this.failedQ.peek(0);
     } else {
       this.log(`No more cards available for the session!`);
+      return null;
+    }
+  }
+  async nextCard(action = "dismiss-success") {
+    this.dismissCurrentCard(action);
+    if (this._secondsRemaining <= 0 && this.failedQ.length === 0) {
       this._currentCard = null;
+      return null;
+    }
+    let card = this.hydrationService.dequeueHydratedCard();
+    if (!card && this.hasAvailableCards()) {
+      card = await this.hydrationService.waitForHydratedCard();
     }
-    return this._currentCard;
+    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,
-            qualifiedID: this._currentCard.qualifiedID,
-            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,
-            qualifiedID: this._currentCard.qualifiedID,
-            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"
           };
         }
-        this.failedQ.add(failedItem);
+        this.failedQ.add(failedItem, failedItem.cardID);
       } else if (action === "dismiss-error") {
       } else if (action === "dismiss-failed") {
       }
     }
   }
-};
-
-// 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
-    });
+  hasAvailableCards() {
+    return this.reviewQ.length > 0 || this.newQ.length > 0 || this.failedQ.length > 0;
   }
-  if (currentAttempt.isCorrect) {
-    const skill = 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;
-    }
-  } 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;
+      this.failedQ.dequeue((queueItem) => queueItem.cardID);
     }
   }
-  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();