@vue-skuilder/db 0.1.7 → 0.1.8-0

package/dist/index.mjs

@@ -80,7 +80,7 @@ var init_logger = __esm({
 });
 
 // src/core/types/types-legacy.ts
-var GuestUsername, log, DocType, cardHistoryPrefix;
+var GuestUsername, log, DocType, DocTypePrefixes;
 var init_types_legacy = __esm({
   "src/core/types/types-legacy.ts"() {
     "use strict";
@@ -89,20 +89,32 @@ var init_types_legacy = __esm({
     log = (message) => {
       logger.log(message);
     };
-    DocType = /* @__PURE__ */ ((DocType2) => {
-      DocType2["DISPLAYABLE_DATA"] = "DISPLAYABLE_DATA";
-      DocType2["CARD"] = "CARD";
-      DocType2["DATASHAPE"] = "DATASHAPE";
-      DocType2["QUESTIONTYPE"] = "QUESTION";
-      DocType2["VIEW"] = "VIEW";
-      DocType2["PEDAGOGY"] = "PEDAGOGY";
-      DocType2["CARDRECORD"] = "CARDRECORD";
-      DocType2["SCHEDULED_CARD"] = "SCHEDULED_CARD";
-      DocType2["TAG"] = "TAG";
-      DocType2["NAVIGATION_STRATEGY"] = "NAVIGATION_STRATEGY";
-      return DocType2;
+    DocType = /* @__PURE__ */ ((DocType3) => {
+      DocType3["DISPLAYABLE_DATA"] = "DISPLAYABLE_DATA";
+      DocType3["CARD"] = "CARD";
+      DocType3["DATASHAPE"] = "DATASHAPE";
+      DocType3["QUESTIONTYPE"] = "QUESTION";
+      DocType3["VIEW"] = "VIEW";
+      DocType3["PEDAGOGY"] = "PEDAGOGY";
+      DocType3["CARDRECORD"] = "CARDRECORD";
+      DocType3["SCHEDULED_CARD"] = "SCHEDULED_CARD";
+      DocType3["TAG"] = "TAG";
+      DocType3["NAVIGATION_STRATEGY"] = "NAVIGATION_STRATEGY";
+      return DocType3;
     })(DocType || {});
-    cardHistoryPrefix = "cardH";
+    DocTypePrefixes = {
+      ["CARD" /* CARD */]: "c",
+      ["DISPLAYABLE_DATA" /* DISPLAYABLE_DATA */]: "dd",
+      ["TAG" /* TAG */]: "TAG",
+      ["CARDRECORD" /* CARDRECORD */]: "cardH",
+      ["SCHEDULED_CARD" /* SCHEDULED_CARD */]: "card_review_",
+      // Add other doctypes here as they get prefixed IDs
+      ["DATASHAPE" /* DATASHAPE */]: "DATASHAPE",
+      ["QUESTION" /* QUESTIONTYPE */]: "QUESTION",
+      ["VIEW" /* VIEW */]: "VIEW",
+      ["PEDAGOGY" /* PEDAGOGY */]: "PEDAGOGY",
+      ["NAVIGATION_STRATEGY" /* NAVIGATION_STRATEGY */]: "NAVIGATION_STRATEGY"
+    };
   }
 });
 
@@ -114,16 +126,16 @@ function isQuestionRecord(c) {
   return c.userAnswer !== void 0;
 }
 function getCardHistoryID(courseID, cardID) {
-  return `${cardHistoryPrefix}-${courseID}-${cardID}`;
+  return `${DocTypePrefixes["CARDRECORD" /* CARDRECORD */]}-${courseID}-${cardID}`;
 }
 function parseCardHistoryID(id) {
   const split = id.split("-");
   let error = "";
   error += split.length === 3 ? "" : `
 	given ID has incorrect number of '-' characters`;
-  error += split[0] === cardHistoryPrefix ? "" : `
-	given ID does not start with ${cardHistoryPrefix}`;
-  if (split.length === 3 && split[0] === cardHistoryPrefix) {
+  error += split[0] === DocTypePrefixes["CARDRECORD" /* CARDRECORD */] ? "" : `
+	given ID does not start with ${DocTypePrefixes["CARDRECORD" /* CARDRECORD */]}`;
+  if (split.length === 3 && split[0] === DocTypePrefixes["CARDRECORD" /* CARDRECORD */]) {
     return {
       courseID: split[1],
       cardID: split[2]
@@ -341,11 +353,11 @@ function scheduleCardReviewLocal(userDB, review) {
   const now = moment.utc();
   logger.info(`Scheduling for review in: ${review.time.diff(now, "h") / 24} days`);
   void userDB.put({
-    _id: REVIEW_PREFIX + review.time.format(REVIEW_TIME_FORMAT),
+    _id: DocTypePrefixes["SCHEDULED_CARD" /* SCHEDULED_CARD */] + review.time.format(REVIEW_TIME_FORMAT),
     cardId: review.card_id,
-    reviewTime: review.time,
+    reviewTime: review.time.toISOString(),
     courseId: review.course_id,
-    scheduledAt: now,
+    scheduledAt: now.toISOString(),
     scheduledFor: review.scheduledFor,
     schedulingAgentId: review.schedulingAgentId
   });
@@ -361,14 +373,14 @@ async function removeScheduledCardReviewLocal(userDB, reviewDocID) {
 ${JSON.stringify(err)}`);
   });
 }
-var REVIEW_PREFIX, REVIEW_TIME_FORMAT, log2;
+var REVIEW_TIME_FORMAT, log2;
 var init_userDBHelpers = __esm({
   "src/impl/common/userDBHelpers.ts"() {
     "use strict";
+    init_core();
     init_logger();
     init_pouchdb_setup();
     init_dataDirectory();
-    REVIEW_PREFIX = "card_review_";
     REVIEW_TIME_FORMAT = "YYYY-MM-DD--kk:mm:ss-SSS";
     log2 = (s) => {
       logger.info(s);
@@ -403,7 +415,10 @@ var init_updateQueue = __esm({
       _className = "UpdateQueue";
       pendingUpdates = {};
       inprogressUpdates = {};
-      db;
+      readDB;
+      // Database for read operations
+      writeDB;
+      // Database for write operations (local-first)
       update(id, update) {
         logger.debug(`Update requested on doc: ${id}`);
         if (this.pendingUpdates[id]) {
@@ -413,24 +428,25 @@ var init_updateQueue = __esm({
         }
         return this.applyUpdates(id);
       }
-      constructor(db) {
+      constructor(readDB, writeDB) {
         super();
-        this.db = db;
+        this.readDB = readDB;
+        this.writeDB = writeDB || readDB;
         logger.debug(`UpdateQ initialized...`);
-        void this.db.info().then((i) => {
+        void this.readDB.info().then((i) => {
           logger.debug(`db info: ${JSON.stringify(i)}`);
         });
       }
       async applyUpdates(id) {
         logger.debug(`Applying updates on doc: ${id}`);
         if (this.inprogressUpdates[id]) {
-          await this.db.info();
+          await this.readDB.info();
           return this.applyUpdates(id);
         } else {
           if (this.pendingUpdates[id] && this.pendingUpdates[id].length > 0) {
             this.inprogressUpdates[id] = true;
             try {
-              let doc = await this.db.get(id);
+              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];
@@ -443,7 +459,7 @@ var init_updateQueue = __esm({
                   };
                 }
               }
-              await this.db.put(doc);
+              await this.writeDB.put(doc);
               logger.debug(`Put doc: ${id}`);
               if (this.pendingUpdates[id].length === 0) {
                 this.inprogressUpdates[id] = false;
@@ -469,6 +485,60 @@ var init_updateQueue = __esm({
   }
 });
 
+// src/impl/couch/user-course-relDB.ts
+import moment2 from "moment";
+var UsrCrsData;
+var init_user_course_relDB = __esm({
+  "src/impl/couch/user-course-relDB.ts"() {
+    "use strict";
+    init_logger();
+    UsrCrsData = class {
+      user;
+      _courseId;
+      constructor(user, courseId) {
+        this.user = user;
+        this._courseId = courseId;
+      }
+      async getReviewsForcast(daysCount) {
+        const time = moment2.utc().add(daysCount, "days");
+        return this.getReviewstoDate(time);
+      }
+      async getPendingReviews() {
+        const now = moment2.utc();
+        return this.getReviewstoDate(now);
+      }
+      async getScheduledReviewCount() {
+        return (await this.getPendingReviews()).length;
+      }
+      async getCourseSettings() {
+        const regDoc = await this.user.getCourseRegistrationsDoc();
+        const crsDoc = regDoc.courses.find((c) => c.courseID === this._courseId);
+        if (crsDoc && crsDoc.settings) {
+          return crsDoc.settings;
+        } else {
+          logger.warn(`no settings found during lookup on course ${this._courseId}`);
+          return {};
+        }
+      }
+      updateCourseSettings(updates) {
+        if ("updateCourseSettings" in this.user) {
+          void this.user.updateCourseSettings(this._courseId, updates);
+        }
+      }
+      async getReviewstoDate(targetDate) {
+        const allReviews = await this.user.getPendingReviews(this._courseId);
+        logger.debug(
+          `Fetching ${this.user.getUsername()}'s scheduled reviews for course ${this._courseId}.`
+        );
+        return allReviews.filter((review) => {
+          const reviewTime = moment2.utc(review.reviewTime);
+          return targetDate.isAfter(reviewTime);
+        });
+      }
+    };
+  }
+});
+
 // src/impl/couch/clientCache.ts
 async function GET_CACHED(k, f) {
   if (CLIENT_CACHE[k]) {
@@ -492,10 +562,12 @@ var init_clientCache = __esm({
 import { NameSpacer } from "@vue-skuilder/common";
 import { blankCourseElo, toCourseElo } from "@vue-skuilder/common";
 import { prepareNote55 } from "@vue-skuilder/common";
+import { v4 as uuidv4 } from "uuid";
 async function addNote55(courseID, codeCourse, shape, data, author, tags, uploads, elo = blankCourseElo()) {
   const db = getCourseDB(courseID);
   const payload = prepareNote55(courseID, codeCourse, shape, data, author, tags, uploads);
-  const result = await db.post(payload);
+  const _id = `${DocTypePrefixes["DISPLAYABLE_DATA" /* DISPLAYABLE_DATA */]}-${uuidv4()}`;
+  const result = await db.put({ ...payload, _id });
   const dataShapeId = NameSpacer.getDataShapeString({
     course: codeCourse,
     dataShape: shape.name
@@ -566,7 +638,9 @@ async function createCard(questionViewName, courseID, dsDescriptor, noteID, tags
 }
 async function addCard(courseID, course, id_displayable_data, id_view, elo, tags, author) {
   const db = getCourseDB(courseID);
-  const card = await db.post({
+  const _id = `${DocTypePrefixes["CARD" /* CARD */]}-${uuidv4()}`;
+  const card = await db.put({
+    _id,
     course,
     id_displayable_data,
     id_view,
@@ -1475,7 +1549,7 @@ ${above.rows.map((r) => `	${r.id}-${r.key}
 });
 
 // src/impl/couch/classroomDB.ts
-import moment2 from "moment";
+import moment3 from "moment";
 var classroomLookupDBTitle, CLASSROOM_CONFIG, ClassroomDBBase, StudentClassroomDB, TeacherClassroomDB, ClassroomLookupDB;
 var init_classroomDB2 = __esm({
   "src/impl/couch/classroomDB.ts"() {
@@ -1576,9 +1650,9 @@ var init_classroomDB2 = __esm({
       }
       async getNewCards() {
         const activeCards = await this._user.getActiveCards();
-        const now = moment2.utc();
+        const now = moment3.utc();
         const assigned = await this.getAssignedContent();
-        const due = assigned.filter((c) => now.isAfter(moment2.utc(c.activeOn, REVIEW_TIME_FORMAT2)));
+        const due = assigned.filter((c) => now.isAfter(moment3.utc(c.activeOn, REVIEW_TIME_FORMAT2)));
         logger.info(`Due content: ${JSON.stringify(due)}`);
         let ret = [];
         for (let i = 0; i < due.length; i++) {
@@ -1669,8 +1743,8 @@ var init_classroomDB2 = __esm({
             type: "tag",
             _id: id,
             assignedBy: content.assignedBy,
-            assignedOn: moment2.utc(),
-            activeOn: content.activeOn || moment2.utc()
+            assignedOn: moment3.utc(),
+            activeOn: content.activeOn || moment3.utc()
           });
         } else {
           put = await this._db.put({
@@ -1678,8 +1752,8 @@ var init_classroomDB2 = __esm({
             type: "course",
             _id: id,
             assignedBy: content.assignedBy,
-            assignedOn: moment2.utc(),
-            activeOn: content.activeOn || moment2.utc()
+            assignedOn: moment3.utc(),
+            activeOn: content.activeOn || moment3.utc()
           });
         }
         if (put.ok) {
@@ -1842,6 +1916,13 @@ var init_CouchDBSyncStrategy = __esm({
           return this.getUserDB(username);
         }
       }
+      getWriteDB(username) {
+        if (username === GuestUsername || username.startsWith(GuestUsername)) {
+          return getLocalUserDB(username);
+        } else {
+          return this.getUserDB(username);
+        }
+      }
       startSync(localDB, remoteDB) {
         if (localDB !== remoteDB) {
           this.syncHandle = pouchdb_setup_default.sync(localDB, remoteDB, {
@@ -1987,7 +2068,7 @@ var init_CouchDBSyncStrategy = __esm({
 });
 
 // src/impl/couch/index.ts
-import moment3 from "moment";
+import moment4 from "moment";
 import process2 from "process";
 function getCourseDB2(courseID) {
   return new pouchdb_setup_default(
@@ -2021,7 +2102,7 @@ function getStartAndEndKeys2(key) {
     endkey: key + "\uFFF0"
   };
 }
-var isBrowser, GUEST_LOCAL_DB, localUserDB, pouchDBincludeCredentialsConfig, REVIEW_PREFIX2, REVIEW_TIME_FORMAT2;
+var isBrowser, GUEST_LOCAL_DB, localUserDB, pouchDBincludeCredentialsConfig, REVIEW_TIME_FORMAT2;
 var init_couch = __esm({
   "src/impl/couch/index.ts"() {
     "use strict";
@@ -2047,78 +2128,10 @@ var init_couch = __esm({
         return pouchdb_setup_default.fetch(url, opts);
       }
     };
-    REVIEW_PREFIX2 = "card_review_";
     REVIEW_TIME_FORMAT2 = "YYYY-MM-DD--kk:mm:ss-SSS";
   }
 });
 
-// src/impl/couch/user-course-relDB.ts
-import moment4 from "moment";
-var UsrCrsData;
-var init_user_course_relDB = __esm({
-  "src/impl/couch/user-course-relDB.ts"() {
-    "use strict";
-    init_couch();
-    init_courseDB();
-    init_logger();
-    UsrCrsData = class {
-      user;
-      course;
-      _courseId;
-      constructor(user, courseId) {
-        this.user = user;
-        this.course = new CourseDB(courseId, async () => this.user);
-        this._courseId = courseId;
-      }
-      async getReviewsForcast(daysCount) {
-        const time = moment4.utc().add(daysCount, "days");
-        return this.getReviewstoDate(time);
-      }
-      async getPendingReviews() {
-        const now = moment4.utc();
-        return this.getReviewstoDate(now);
-      }
-      async getScheduledReviewCount() {
-        return (await this.getPendingReviews()).length;
-      }
-      async getCourseSettings() {
-        const regDoc = await this.user.getCourseRegistrationsDoc();
-        const crsDoc = regDoc.courses.find((c) => c.courseID === this._courseId);
-        if (crsDoc && crsDoc.settings) {
-          return crsDoc.settings;
-        } else {
-          logger.warn(`no settings found during lookup on course ${this._courseId}`);
-          return {};
-        }
-      }
-      updateCourseSettings(updates) {
-        void this.user.updateCourseSettings(this._courseId, updates);
-      }
-      async getReviewstoDate(targetDate) {
-        const keys = getStartAndEndKeys2(REVIEW_PREFIX2);
-        const reviews = await this.user.remote().allDocs({
-          startkey: keys.startkey,
-          endkey: keys.endkey,
-          include_docs: true
-        });
-        logger.debug(
-          `Fetching ${this.user.getUsername()}'s scheduled reviews for course ${this._courseId}.`
-        );
-        return reviews.rows.filter((r) => {
-          if (r.id.startsWith(REVIEW_PREFIX2)) {
-            const date = moment4.utc(r.id.substr(REVIEW_PREFIX2.length), REVIEW_TIME_FORMAT2);
-            if (targetDate.isAfter(date)) {
-              if (this._courseId === void 0 || r.doc.courseId === this._courseId) {
-                return true;
-              }
-            }
-          }
-        }).map((r) => r.doc);
-      }
-    };
-  }
-});
-
 // src/impl/common/BaseUserDB.ts
 import { Status as Status3 } from "@vue-skuilder/common";
 import moment5 from "moment";
@@ -2214,10 +2227,11 @@ async function dropUserFromClassroom(user, classID) {
 async function getUserClassrooms(user) {
   return getOrCreateClassroomRegistrationsDoc(user);
 }
-var log4, cardHistoryPrefix2, BaseUser, userCoursesDoc, userClassroomsDoc;
+var log4, BaseUser, userCoursesDoc, userClassroomsDoc;
 var init_BaseUserDB = __esm({
   "src/impl/common/BaseUserDB.ts"() {
     "use strict";
+    init_core();
     init_util();
     init_types_legacy();
     init_logger();
@@ -2228,7 +2242,6 @@ var init_BaseUserDB = __esm({
     log4 = (s) => {
       logger.info(s);
     };
-    cardHistoryPrefix2 = "cardH-";
     BaseUser = class _BaseUser {
       static _instance;
       static _initialized = false;
@@ -2249,11 +2262,13 @@ var init_BaseUserDB = __esm({
       isLoggedIn() {
         return !this._username.startsWith(GuestUsername);
       }
-      remoteDB;
       remote() {
         return this.remoteDB;
       }
       localDB;
+      remoteDB;
+      writeDB;
+      // Database to use for write operations (local-first approach)
       updateQueue;
       async createAccount(username, password) {
         if (!this.syncStrategy.canCreateAccount()) {
@@ -2317,8 +2332,8 @@ Currently logged-in as ${this._username}.`
           const allDocs = await localDB.allDocs({ include_docs: false });
           const docsToDelete = allDocs.rows.filter((row) => {
             const id = row.id;
-            return id.startsWith(cardHistoryPrefix2) || // Card interaction history
-            id.startsWith(REVIEW_PREFIX) || // Scheduled reviews
+            return id.startsWith(DocTypePrefixes["CARDRECORD" /* CARDRECORD */]) || // Card interaction history
+            id.startsWith(DocTypePrefixes["SCHEDULED_CARD" /* SCHEDULED_CARD */]) || // Scheduled reviews
             id === _BaseUser.DOC_IDS.COURSE_REGISTRATIONS || // Course registrations
             id === _BaseUser.DOC_IDS.CLASSROOM_REGISTRATIONS || // Classroom registrations
             id === _BaseUser.DOC_IDS.CONFIG;
@@ -2387,7 +2402,7 @@ Currently logged-in as ${this._username}.`
        *
        */
       async getActiveCards() {
-        const keys = getStartAndEndKeys(REVIEW_PREFIX);
+        const keys = getStartAndEndKeys(DocTypePrefixes["SCHEDULED_CARD" /* SCHEDULED_CARD */]);
         const reviews = await this.remoteDB.allDocs({
           startkey: keys.startkey,
           endkey: keys.endkey,
@@ -2459,7 +2474,7 @@ Currently logged-in as ${this._username}.`
         }
       }
       async getReviewstoDate(targetDate, course_id) {
-        const keys = getStartAndEndKeys(REVIEW_PREFIX);
+        const keys = getStartAndEndKeys(DocTypePrefixes["SCHEDULED_CARD" /* SCHEDULED_CARD */]);
         const reviews = await this.remoteDB.allDocs({
           startkey: keys.startkey,
           endkey: keys.endkey,
@@ -2469,8 +2484,11 @@ Currently logged-in as ${this._username}.`
           `Fetching ${this._username}'s scheduled reviews${course_id ? ` for course ${course_id}` : ""}.`
         );
         return reviews.rows.filter((r) => {
-          if (r.id.startsWith(REVIEW_PREFIX)) {
-            const date = moment5.utc(r.id.substr(REVIEW_PREFIX.length), REVIEW_TIME_FORMAT);
+          if (r.id.startsWith(DocTypePrefixes["SCHEDULED_CARD" /* SCHEDULED_CARD */])) {
+            const date = moment5.utc(
+              r.id.substr(DocTypePrefixes["SCHEDULED_CARD" /* SCHEDULED_CARD */].length),
+              REVIEW_TIME_FORMAT
+            );
             if (targetDate.isAfter(date)) {
               if (course_id === void 0 || r.doc.courseId === course_id) {
                 return true;
@@ -2585,7 +2603,8 @@ Currently logged-in as ${this._username}.`
         const defaultConfig = {
           _id: _BaseUser.DOC_IDS.CONFIG,
           darkMode: false,
-          likesConfetti: false
+          likesConfetti: false,
+          sessionTimeLimit: 5
         };
         try {
           const cfg = await this.localDB.get(_BaseUser.DOC_IDS.CONFIG);
@@ -2658,7 +2677,8 @@ Currently logged-in as ${this._username}.`
       setDBandQ() {
         this.localDB = getLocalUserDB(this._username);
         this.remoteDB = this.syncStrategy.setupRemoteDB(this._username);
-        this.updateQueue = new UpdateQueue(this.localDB);
+        this.writeDB = this.syncStrategy.getWriteDB ? this.syncStrategy.getWriteDB(this._username) : this.localDB;
+        this.updateQueue = new UpdateQueue(this.localDB, this.writeDB);
       }
       async init() {
         _BaseUser._initialized = false;
@@ -2776,8 +2796,8 @@ Currently logged-in as ${this._username}.`
               streak: 0,
               bestInterval: 0
             };
-            void this.remoteDB.put(initCardHistory);
-            return initCardHistory;
+            const putResult = await this.writeDB.put(initCardHistory);
+            return { ...initCardHistory, _rev: putResult.rev };
           } else {
             throw new Error(`putCardRecord failed because of:
   name:${reason.name}
@@ -2812,7 +2832,7 @@ Currently logged-in as ${this._username}.`
             const deletePromises = duplicateDocIds.map(async (docId) => {
               try {
                 const doc = await this.remoteDB.get(docId);
-                await this.remoteDB.remove(doc);
+                await this.writeDB.remove(doc);
                 log4(`Successfully removed duplicate review: ${docId}`);
               } catch (error) {
                 log4(`Failed to remove duplicate review ${docId}: ${error}`);
@@ -2834,7 +2854,7 @@ Currently logged-in as ${this._username}.`
        * @param course_id optional specification of individual course
        */
       async getSeenCards(course_id) {
-        let prefix = cardHistoryPrefix2;
+        let prefix = DocTypePrefixes["CARDRECORD" /* CARDRECORD */];
         if (course_id) {
           prefix += course_id;
         }
@@ -2843,8 +2863,8 @@ Currently logged-in as ${this._username}.`
         });
         const ret = [];
         docs.rows.forEach((row) => {
-          if (row.id.startsWith(cardHistoryPrefix2)) {
-            ret.push(row.id.substr(cardHistoryPrefix2.length));
+          if (row.id.startsWith(DocTypePrefixes["CARDRECORD" /* CARDRECORD */])) {
+            ret.push(row.id.substr(DocTypePrefixes["CARDRECORD" /* CARDRECORD */].length));
           }
         });
         return ret;
@@ -2856,7 +2876,7 @@ Currently logged-in as ${this._username}.`
       async getHistory() {
         const cards = await filterAllDocsByPrefix(
           this.remoteDB,
-          cardHistoryPrefix2,
+          DocTypePrefixes["CARDRECORD" /* CARDRECORD */],
           {
             include_docs: true,
             attachments: false
@@ -2897,7 +2917,7 @@ Currently logged-in as ${this._username}.`
         } catch (e) {
           const err = e;
           if (err.status === 404) {
-            await this.remoteDB.put({
+            await this.writeDB.put({
               _id: _BaseUser.DOC_IDS.CLASSROOM_REGISTRATIONS,
               registrations: []
             });
@@ -2945,10 +2965,10 @@ Currently logged-in as ${this._username}.`
         }
       }
       async scheduleCardReview(review) {
-        return scheduleCardReviewLocal(this.remoteDB, review);
+        return scheduleCardReviewLocal(this.writeDB, review);
       }
       async removeScheduledCardReview(reviewId) {
-        return removeScheduledCardReviewLocal(this.remoteDB, reviewId);
+        return removeScheduledCardReviewLocal(this.writeDB, reviewId);
       }
       async registerForClassroom(_classId, _registerAs) {
         return registerUserForClassroom(this._username, _classId, _registerAs);
@@ -3160,18 +3180,21 @@ var init_StaticDataUnpacker = __esm({
       async getTagsIndex() {
         return await this.loadIndex("tags");
       }
+      getDocTypeFromId(id) {
+        for (const docTypeKey in DocTypePrefixes) {
+          const prefix = DocTypePrefixes[docTypeKey];
+          if (id.startsWith(`${prefix}-`)) {
+            return docTypeKey;
+          }
+        }
+        return void 0;
+      }
       /**
        * Find which chunk contains a specific document ID
        */
       async findChunkForDocument(docId) {
-        let expectedDocType = void 0;
-        for (const docType of Object.values(DocType)) {
-          if (docId.startsWith(`${docType}-`)) {
-            expectedDocType = docType;
-            break;
-          }
-        }
-        if (expectedDocType !== void 0) {
+        const expectedDocType = this.getDocTypeFromId(docId);
+        if (expectedDocType) {
           const typeChunks = this.manifest.chunks.filter((c) => c.docType === expectedDocType);
           for (const chunk of typeChunks) {
             if (docId >= chunk.startKey && docId <= chunk.endKey) {
@@ -3181,21 +3204,8 @@ var init_StaticDataUnpacker = __esm({
               }
             }
           }
-          return void 0;
         } else {
-          const displayableChunks = this.manifest.chunks.filter(
-            (c) => c.docType === "DISPLAYABLE_DATA"
-          );
-          for (const chunk of displayableChunks) {
-            if (docId >= chunk.startKey && docId <= chunk.endKey) {
-              const exists = await this.verifyDocumentInChunk(docId, chunk);
-              if (exists) {
-                return chunk;
-              }
-            }
-          }
-          const cardChunks = this.manifest.chunks.filter((c) => c.docType === "CARD");
-          for (const chunk of cardChunks) {
+          for (const chunk of this.manifest.chunks) {
             if (docId >= chunk.startKey && docId <= chunk.endKey) {
               const exists = await this.verifyDocumentInChunk(docId, chunk);
               if (exists) {
@@ -3216,6 +3226,7 @@ var init_StaticDataUnpacker = __esm({
           }
           return void 0;
         }
+        return void 0;
       }
       /**
        * Verify that a document actually exists in a specific chunk by loading and checking it
@@ -3459,6 +3470,7 @@ var init_courseDB2 = __esm({
     "use strict";
     init_types_legacy();
     init_navigators();
+    init_logger();
     StaticCourseDB = class {
       constructor(courseId, unpacker, userDB, manifest) {
         this.courseId = courseId;
@@ -3480,10 +3492,11 @@ var init_courseDB2 = __esm({
         throw new Error("Cannot update course config in static mode");
       }
       async getCourseInfo() {
+        const cardCount = this.manifest.chunks.filter((chunk) => chunk.docType === "CARD" /* CARD */).reduce((total, chunk) => total + chunk.documentCount, 0);
         return {
-          cardCount: 0,
-          // Would come from manifest
+          cardCount,
           registeredUsers: 0
+          // Always 0 in static mode
         };
       }
       async getCourseDoc(id, _options) {
@@ -3572,12 +3585,56 @@ var init_courseDB2 = __esm({
           courseID: this.courseId
         }));
       }
-      async getAppliedTags(_cardId) {
-        return {
-          total_rows: 0,
-          offset: 0,
-          rows: []
-        };
+      async getAppliedTags(cardId) {
+        try {
+          const tagsIndex = await this.unpacker.getTagsIndex();
+          const cardTags = tagsIndex.byCard[cardId] || [];
+          const rows = await Promise.all(
+            cardTags.map(async (tagName) => {
+              const tagId = `${"TAG" /* TAG */}-${tagName}`;
+              try {
+                const tagDoc = await this.unpacker.getDocument(tagId);
+                return {
+                  id: tagId,
+                  key: cardId,
+                  value: {
+                    name: tagDoc.name,
+                    snippet: tagDoc.snippet,
+                    count: tagDoc.taggedCards?.length || 0
+                  }
+                };
+              } catch (error) {
+                if (error && error.status === 404) {
+                  logger.warn(`Tag document not found for ${tagName}, creating stub`);
+                } else {
+                  logger.error(`Error getting tag document for ${tagName}:`, error);
+                  throw error;
+                }
+                return {
+                  id: tagId,
+                  key: cardId,
+                  value: {
+                    name: tagName,
+                    snippet: `Tag: ${tagName}`,
+                    count: tagsIndex.byTag[tagName]?.length || 0
+                  }
+                };
+              }
+            })
+          );
+          return {
+            total_rows: rows.length,
+            offset: 0,
+            rows
+          };
+        } catch (error) {
+          logger.error(`Error getting applied tags for card ${cardId}:`, error);
+          return {
+            total_rows: 0,
+            offset: 0,
+            rows: []
+          };
+        }
       }
       async addTagToCard(_cardId, _tagId) {
         throw new Error("Cannot modify tags in static mode");
@@ -3595,11 +3652,69 @@ var init_courseDB2 = __esm({
         throw new Error("Cannot update tags in static mode");
       }
       async getCourseTagStubs() {
-        return {
-          total_rows: 0,
-          offset: 0,
-          rows: []
-        };
+        try {
+          const tagsIndex = await this.unpacker.getTagsIndex();
+          if (!tagsIndex || !tagsIndex.byTag) {
+            logger.warn("Tags index not found or empty");
+            return {
+              total_rows: 0,
+              offset: 0,
+              rows: []
+            };
+          }
+          const tagNames = Object.keys(tagsIndex.byTag);
+          const rows = await Promise.all(
+            tagNames.map(async (tagName) => {
+              const cardIds = tagsIndex.byTag[tagName] || [];
+              const tagId = `${"TAG" /* TAG */}-${tagName}`;
+              try {
+                const tagDoc = await this.unpacker.getDocument(tagId);
+                return {
+                  id: tagId,
+                  key: tagId,
+                  value: { rev: "1-static" },
+                  doc: tagDoc
+                };
+              } catch (error) {
+                if (error && error.status === 404) {
+                  logger.warn(`Tag document not found for ${tagName}, creating stub`);
+                  const stubDoc = {
+                    _id: tagId,
+                    _rev: "1-static",
+                    course: this.courseId,
+                    docType: "TAG" /* TAG */,
+                    name: tagName,
+                    snippet: `Tag: ${tagName}`,
+                    wiki: "",
+                    taggedCards: cardIds,
+                    author: "system"
+                  };
+                  return {
+                    id: tagId,
+                    key: tagId,
+                    value: { rev: "1-static" },
+                    doc: stubDoc
+                  };
+                } else {
+                  logger.error(`Error getting tag document for ${tagName}:`, error);
+                  throw error;
+                }
+              }
+            })
+          );
+          return {
+            total_rows: rows.length,
+            offset: 0,
+            rows
+          };
+        } catch (error) {
+          logger.error("Failed to get course tag stubs:", error);
+          return {
+            total_rows: 0,
+            offset: 0,
+            rows: []
+          };
+        }
       }
       async addNote(_codeCourse, _shape, _data, _author, _tags, _uploads, _elo) {
         return {
@@ -3705,6 +3820,9 @@ var init_NoOpSyncStrategy = __esm({
       setupRemoteDB(username) {
         return getLocalUserDB(username);
       }
+      getWriteDB(username) {
+        return getLocalUserDB(username);
+      }
       startSync(_localDB, _remoteDB) {
       }
       stopSync() {
@@ -4156,6 +4274,57 @@ var CouchDBToStaticPacker = class {
       attachments
     };
   }
+  /**
+   * Pack a CouchDB course database and write the static files to disk
+   */
+  async packCourseToFiles(sourceDB, courseId, outputDir, fsAdapter) {
+    logger.info(`Packing course ${courseId} to files in ${outputDir}`);
+    const packedData = await this.packCourse(sourceDB, courseId);
+    const filesWritten = await this.writePackedDataToFiles(packedData, outputDir, fsAdapter);
+    return {
+      manifest: packedData.manifest,
+      filesWritten,
+      attachmentsFound: packedData.attachments ? packedData.attachments.size : 0
+    };
+  }
+  /**
+   * Write packed course data to files using FileSystemAdapter
+   */
+  async writePackedDataToFiles(packedData, outputDir, fsAdapter) {
+    let totalFiles = 0;
+    await fsAdapter.ensureDir(outputDir);
+    const manifestPath = fsAdapter.joinPath(outputDir, "manifest.json");
+    await fsAdapter.writeJson(manifestPath, packedData.manifest, { spaces: 2 });
+    totalFiles++;
+    logger.info(`Wrote manifest: ${manifestPath}`);
+    const chunksDir = fsAdapter.joinPath(outputDir, "chunks");
+    const indicesDir = fsAdapter.joinPath(outputDir, "indices");
+    await fsAdapter.ensureDir(chunksDir);
+    await fsAdapter.ensureDir(indicesDir);
+    for (const [chunkId, chunkData] of packedData.chunks) {
+      const chunkPath = fsAdapter.joinPath(chunksDir, `${chunkId}.json`);
+      await fsAdapter.writeJson(chunkPath, chunkData);
+      totalFiles++;
+    }
+    logger.info(`Wrote ${packedData.chunks.size} chunk files`);
+    for (const [indexName, indexData] of packedData.indices) {
+      const indexPath = fsAdapter.joinPath(indicesDir, `${indexName}.json`);
+      await fsAdapter.writeJson(indexPath, indexData, { spaces: 2 });
+      totalFiles++;
+    }
+    logger.info(`Wrote ${packedData.indices.size} index files`);
+    if (packedData.attachments && packedData.attachments.size > 0) {
+      for (const [attachmentPath, attachmentData] of packedData.attachments) {
+        const fullAttachmentPath = fsAdapter.joinPath(outputDir, attachmentPath);
+        const attachmentDir = fsAdapter.dirname(fullAttachmentPath);
+        await fsAdapter.ensureDir(attachmentDir);
+        await fsAdapter.writeFile(fullAttachmentPath, attachmentData.buffer);
+        totalFiles++;
+      }
+      logger.info(`Wrote ${packedData.attachments.size} attachment files`);
+    }
+    return totalFiles;
+  }
   async extractCourseConfig(db) {
     try {
       return await db.get("CourseConfig");
@@ -4324,7 +4493,8 @@ var CouchDBToStaticPacker = class {
     }
     try {
       const designDocId = designDoc._id;
-      const viewPath = `${designDocId}/${viewName}`;
+      const designDocName = designDocId.replace("_design/", "");
+      const viewPath = `${designDocName}/${viewName}`;
       logger.info(`Querying CouchDB view: ${viewPath}`);
       const viewResults = await this.sourceDB.query(viewPath, {
         include_docs: false
@@ -5249,6 +5419,7 @@ var StaticToCouchDBMigrator = class {
         const docsToInsert = batch.map((doc) => {
           const cleanDoc = { ...doc };
           delete cleanDoc._rev;
+          delete cleanDoc._attachments;
           return cleanDoc;
         });
         const bulkResult = await db.bulkDocs(docsToInsert);
@@ -5362,9 +5533,11 @@ var StaticToCouchDBMigrator = class {
           attachmentData = await response.arrayBuffer();
         }
       }
+      const doc = await db.get(docId);
       await db.putAttachment(
         docId,
         attachmentName,
+        doc._rev,
         attachmentData,
         // PouchDB accepts both ArrayBuffer and Buffer
         attachmentMeta.content_type
@@ -5832,6 +6005,7 @@ export {
   CouchDBToStaticPacker,
   CourseLookup,
   DocType,
+  DocTypePrefixes,
   ENV,
   FileSystemError,
   GuestUsername,
@@ -5841,7 +6015,6 @@ export {
   StaticToCouchDBMigrator,
   _resetDataLayer,
   areQuestionRecords,
-  cardHistoryPrefix,
   docIsDeleted,
   ensureAppDataDirectory,
   getAppDataDirectory,