@vue-skuilder/db 0.1.11-7 → 0.1.11

package/dist/index.mjs

@@ -165,9 +165,9 @@ var init_pouchdb_setup = __esm({
     PouchDB.plugin(PouchDBFind);
     PouchDB.plugin(PouchDBAuth);
     PouchDB.defaults({
-      ajax: {
-        timeout: 6e4
-      }
+      // ajax: {
+      //   timeout: 60000,
+      // },
     });
     pouchdb_setup_default = PouchDB;
   }
@@ -450,37 +450,48 @@ var init_updateQueue = __esm({
         } 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 {
+                  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`);
           }
@@ -735,7 +746,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 AlreadyTaggedErr;
@@ -857,6 +868,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
@@ -927,13 +939,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"
@@ -981,7 +996,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 module = await globImport(`./${implementingClass}${ext}`);
@@ -1290,7 +1305,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}
 `)}
@@ -1345,7 +1366,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);
@@ -1538,17 +1565,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);
+      }
     };
   }
 });
@@ -1614,7 +1717,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);
@@ -1683,9 +1786,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;
@@ -1704,11 +1809,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) => {
@@ -1793,7 +1898,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() {
@@ -1855,9 +1960,10 @@ import fetch2 from "cross-fetch";
 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 fetch2(url, {
       method: "GET",
@@ -1869,8 +1975,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() {
@@ -2063,7 +2171,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);
@@ -2078,10 +2186,29 @@ var init_CouchDBSyncStrategy = __esm({
 import fetch3 from "cross-fetch";
 import moment4 from "moment";
 import process2 from "process";
+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 = {}) {
@@ -2370,6 +2497,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);
       }
@@ -2416,7 +2546,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 {
@@ -2696,8 +2831,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 = [
@@ -2715,10 +2860,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);
@@ -2817,8 +2967,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) => {
@@ -2853,6 +3008,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)}`);
+          }
         }
       }
       /**
@@ -3086,6 +3252,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;
       }
@@ -3538,7 +3714,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(
@@ -3582,14 +3761,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
@@ -3781,6 +3965,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"
+        };
+      }
     };
   }
 });
@@ -3936,6 +4130,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;
       }
@@ -5655,6 +5855,11 @@ init_dataDirectory();
 init_tuiLogger();
 
 // src/study/SessionController.ts
+import {
+  displayableDataToViewData,
+  isCourseElo,
+  toCourseElo as toCourseElo3
+} from "@vue-skuilder/common";
 function randomInt(min, max) {
   return Math.floor(Math.random() * (max - min + 1)) + min;
 }
@@ -5665,15 +5870,15 @@ var ItemQueue = class {
   get dequeueCount() {
     return this._dequeueCount;
   }
-  add(item) {
-    if (this.seenCardIds.find((d) => d === item.cardID)) {
+  add(item, cardId) {
+    if (this.seenCardIds.find((d) => d === cardId)) {
       return;
     }
-    this.seenCardIds.push(item.cardID);
+    this.seenCardIds.push(cardId);
     this.q.push(item);
   }
-  addAll(items) {
-    items.forEach((i) => this.add(i));
+  addAll(items, cardIdExtractor) {
+    items.forEach((i) => this.add(i, cardIdExtractor(i)));
   }
   get length() {
     return this.q.length;
@@ -5691,12 +5896,14 @@ var ItemQueue = class {
   }
   get toString() {
     return `${typeof this.q[0]}:
-` + this.q.map((i) => `	${i.qualifiedID}: ${i.status}`).join("\n");
+` + this.q.map((i) => `	${i.courseID}+${i.cardID}: ${i.status}`).join("\n");
   }
 };
 var SessionController = class extends Loggable {
   _className = "SessionController";
   sources;
+  dataLayer;
+  getViewComponent;
   _sessionRecord = [];
   set sessionRecord(r) {
     this._sessionRecord = r;
@@ -5704,12 +5911,9 @@ var SessionController = class extends Loggable {
   reviewQ = new ItemQueue();
   newQ = new ItemQueue();
   failedQ = new ItemQueue();
+  hydratedQ = new ItemQueue();
   _currentCard = null;
-  /**
-   * Indicates whether the session has been initialized - eg, the
-   * queues have been populated.
-   */
-  _isInitialized = false;
+  hydration_in_progress = false;
   startTime;
   endTime;
   _secondsRemaining;
@@ -5727,12 +5931,14 @@ var SessionController = class extends Loggable {
   /**
    *
    */
-  constructor(sources, time) {
+  constructor(sources, time, dataLayer, getViewComponent) {
     super();
     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}`);
@@ -5783,7 +5989,7 @@ var SessionController = class extends Loggable {
     } catch (e) {
       this.error("Error preparing study session:", e);
     }
-    this._isInitialized = true;
+    await this._fillHydratedQueue();
     this._intervalHandle = setInterval(() => {
       this.tick();
     }, 1e3);
@@ -5821,12 +6027,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) {
@@ -5841,36 +6043,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(action = "dismiss-success") {
     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();
@@ -5895,16 +6093,27 @@ 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!`);
-      this._currentCard = null;
+      return null;
     }
-    return this._currentCard;
+  }
+  async nextCard(action = "dismiss-success") {
+    this.dismissCurrentCard(action);
+    let card = this.hydratedQ.dequeue();
+    if (!card && this.hasAvailableCards()) {
+      void this._fillHydratedQueue();
+      card = await this.nextHydratedCard();
+    }
+    if (this.hydratedQ.length < 3) {
+      void this._fillHydratedQueue();
+    }
+    return card;
   }
   dismissCurrentCard(action = "dismiss-success") {
     if (this._currentCard) {
@@ -5915,7 +6124,6 @@ var SessionController = class extends Loggable {
           failedItem = {
             cardID: this._currentCard.cardID,
             courseID: this._currentCard.courseID,
-            qualifiedID: this._currentCard.qualifiedID,
             contentSourceID: this._currentCard.contentSourceID,
             contentSourceType: this._currentCard.contentSourceType,
             status: "failed-review",
@@ -5925,18 +6133,80 @@ var SessionController = class extends Loggable {
           failedItem = {
             cardID: this._currentCard.cardID,
             courseID: this._currentCard.courseID,
-            qualifiedID: this._currentCard.qualifiedID,
             contentSourceID: this._currentCard.contentSourceID,
             contentSourceType: this._currentCard.contentSourceType,
             status: "failed-new"
           };
         }
-        this.failedQ.add(failedItem);
+        this.failedQ.add(failedItem, failedItem.cardID);
       } else if (action === "dismiss-error") {
       } else if (action === "dismiss-failed") {
       }
     }
   }
+  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 (!isCourseElo(cardData.elo)) {
+          cardData.elo = toCourseElo3(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(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
@@ -5962,7 +6232,7 @@ function newQuestionInterval(user, cardHistory) {
     });
   }
   if (currentAttempt.isCorrect) {
-    const skill = currentAttempt.performance;
+    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);