@vue-skuilder/db 0.1.7 → 0.1.8-0

package/dist/impl/static/index.js

@@ -102,32 +102,31 @@ var init_SyncStrategy = __esm({
 });
 
 // src/core/types/types-legacy.ts
-var GuestUsername, DocType, cardHistoryPrefix;
+var GuestUsername, DocTypePrefixes;
 var init_types_legacy = __esm({
   "src/core/types/types-legacy.ts"() {
     "use strict";
     init_logger();
     GuestUsername = "Guest";
-    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 || {});
-    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"
+    };
   }
 });
 
 // src/core/util/index.ts
 function getCardHistoryID(courseID, cardID) {
-  return `${cardHistoryPrefix}-${courseID}-${cardID}`;
+  return `${DocTypePrefixes["CARDRECORD" /* CARDRECORD */]}-${courseID}-${cardID}`;
 }
 var init_util = __esm({
   "src/core/util/index.ts"() {
@@ -210,11 +209,11 @@ function scheduleCardReviewLocal(userDB, review) {
   const now = import_moment.default.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
   });
@@ -230,15 +229,15 @@ async function removeScheduledCardReviewLocal(userDB, reviewDocID) {
 ${JSON.stringify(err)}`);
   });
 }
-var import_moment, REVIEW_PREFIX, REVIEW_TIME_FORMAT, log;
+var import_moment, REVIEW_TIME_FORMAT, log;
 var init_userDBHelpers = __esm({
   "src/impl/common/userDBHelpers.ts"() {
     "use strict";
     import_moment = __toESM(require("moment"));
+    init_core();
     init_logger();
     init_pouchdb_setup();
     init_dataDirectory();
-    REVIEW_PREFIX = "card_review_";
     REVIEW_TIME_FORMAT = "YYYY-MM-DD--kk:mm:ss-SSS";
     log = (s) => {
       logger.info(s);
@@ -273,7 +272,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]) {
@@ -283,24 +285,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];
@@ -313,7 +316,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;
@@ -339,114 +342,68 @@ var init_updateQueue = __esm({
   }
 });
 
-// src/impl/couch/clientCache.ts
-async function GET_CACHED(k, f) {
-  if (CLIENT_CACHE[k]) {
-    return CLIENT_CACHE[k];
+// src/impl/couch/user-course-relDB.ts
+var import_moment2, UsrCrsData;
+var init_user_course_relDB = __esm({
+  "src/impl/couch/user-course-relDB.ts"() {
+    "use strict";
+    import_moment2 = __toESM(require("moment"));
+    init_logger();
+    UsrCrsData = class {
+      user;
+      _courseId;
+      constructor(user, courseId) {
+        this.user = user;
+        this._courseId = courseId;
+      }
+      async getReviewsForcast(daysCount) {
+        const time = import_moment2.default.utc().add(daysCount, "days");
+        return this.getReviewstoDate(time);
+      }
+      async getPendingReviews() {
+        const now = import_moment2.default.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 = import_moment2.default.utc(review.reviewTime);
+          return targetDate.isAfter(reviewTime);
+        });
+      }
+    };
   }
-  CLIENT_CACHE[k] = f ? await f(k) : await GET_ITEM(k);
-  return GET_CACHED(k);
-}
-async function GET_ITEM(k) {
-  throw new Error(`No implementation found for GET_CACHED(${k})`);
-}
-var CLIENT_CACHE;
+});
+
+// src/impl/couch/clientCache.ts
 var init_clientCache = __esm({
   "src/impl/couch/clientCache.ts"() {
     "use strict";
-    CLIENT_CACHE = {};
   }
 });
 
 // src/impl/couch/courseAPI.ts
-async function addNote55(courseID, codeCourse, shape, data, author, tags, uploads, elo = (0, import_common2.blankCourseElo)()) {
-  const db = getCourseDB(courseID);
-  const payload = (0, import_common3.prepareNote55)(courseID, codeCourse, shape, data, author, tags, uploads);
-  const result = await db.post(payload);
-  const dataShapeId = import_common.NameSpacer.getDataShapeString({
-    course: codeCourse,
-    dataShape: shape.name
-  });
-  if (result.ok) {
-    try {
-      await createCards(courseID, dataShapeId, result.id, tags, elo, author);
-    } catch (error) {
-      let errorMessage = "Unknown error";
-      if (error instanceof Error) {
-        errorMessage = error.message;
-      } else if (error && typeof error === "object" && "reason" in error) {
-        errorMessage = error.reason;
-      } else if (error && typeof error === "object" && "message" in error) {
-        errorMessage = error.message;
-      } else {
-        errorMessage = String(error);
-      }
-      logger.error(`[addNote55] Failed to create cards for note ${result.id}: ${errorMessage}`);
-      result.cardCreationFailed = true;
-      result.cardCreationError = errorMessage;
-    }
-  } else {
-    logger.error(`[addNote55] Error adding note. Result: ${JSON.stringify(result)}`);
-  }
-  return result;
-}
-async function createCards(courseID, datashapeID, noteID, tags, elo = (0, import_common2.blankCourseElo)(), author) {
-  const cfg = await getCredentialledCourseConfig(courseID);
-  const dsDescriptor = import_common.NameSpacer.getDataShapeDescriptor(datashapeID);
-  let questionViewTypes = [];
-  for (const ds of cfg.dataShapes) {
-    if (ds.name === datashapeID) {
-      questionViewTypes = ds.questionTypes;
-    }
-  }
-  if (questionViewTypes.length === 0) {
-    const errorMsg = `No questionViewTypes found for datashapeID: ${datashapeID} in course config. Cards cannot be created.`;
-    logger.error(errorMsg);
-    throw new Error(errorMsg);
-  }
-  for (const questionView of questionViewTypes) {
-    await createCard(questionView, courseID, dsDescriptor, noteID, tags, elo, author);
-  }
-}
-async function createCard(questionViewName, courseID, dsDescriptor, noteID, tags, elo = (0, import_common2.blankCourseElo)(), author) {
-  const qDescriptor = import_common.NameSpacer.getQuestionDescriptor(questionViewName);
-  const cfg = await getCredentialledCourseConfig(courseID);
-  for (const rQ of cfg.questionTypes) {
-    if (rQ.name === questionViewName) {
-      for (const view of rQ.viewList) {
-        await addCard(
-          courseID,
-          dsDescriptor.course,
-          [noteID],
-          import_common.NameSpacer.getViewString({
-            course: qDescriptor.course,
-            questionType: qDescriptor.questionType,
-            view
-          }),
-          elo,
-          tags,
-          author
-        );
-      }
-    }
-  }
-}
-async function addCard(courseID, course, id_displayable_data, id_view, elo, tags, author) {
-  const db = getCourseDB(courseID);
-  const card = await db.post({
-    course,
-    id_displayable_data,
-    id_view,
-    docType: "CARD" /* CARD */,
-    elo: elo || (0, import_common2.toCourseElo)(990 + Math.round(20 * Math.random())),
-    author
-  });
-  for (const tag of tags) {
-    logger.info(`adding tag: ${tag} to card ${card.id}`);
-    await addTagToCard(courseID, card.id, tag, author, false);
-  }
-  return card;
-}
 async function getCredentialledCourseConfig(courseID) {
   try {
     const db = getCourseDB(courseID);
@@ -459,66 +416,6 @@ async function getCredentialledCourseConfig(courseID) {
     throw e;
   }
 }
-async function addTagToCard(courseID, cardID, tagID, author, updateELO = true) {
-  const prefixedTagID = getTagID(tagID);
-  const courseDB = getCourseDB(courseID);
-  const courseApi = new CourseDB(courseID, async () => {
-    const dummySyncStrategy = {
-      setupRemoteDB: () => null,
-      startSync: () => {
-      },
-      canCreateAccount: () => false,
-      canAuthenticate: () => false,
-      getCurrentUsername: async () => "DummyUser"
-    };
-    return BaseUser.Dummy(dummySyncStrategy);
-  });
-  try {
-    logger.info(`Applying tag ${tagID} to card ${courseID + "-" + cardID}...`);
-    const tag = await courseDB.get(prefixedTagID);
-    if (!tag.taggedCards.includes(cardID)) {
-      tag.taggedCards.push(cardID);
-      if (updateELO) {
-        try {
-          const eloData = await courseApi.getCardEloData([cardID]);
-          const elo = eloData[0];
-          elo.tags[tagID] = {
-            count: 0,
-            score: elo.global.score
-            // todo: or 1000?
-          };
-          await updateCardElo(courseID, cardID, elo);
-        } catch (error) {
-          logger.error("Failed to update ELO data for card:", cardID, error);
-        }
-      }
-      return courseDB.put(tag);
-    } else throw new AlreadyTaggedErr(`Card ${cardID} is already tagged with ${tagID}`);
-  } catch (e) {
-    if (e instanceof AlreadyTaggedErr) {
-      throw e;
-    }
-    await createTag(courseID, tagID, author);
-    return addTagToCard(courseID, cardID, tagID, author, updateELO);
-  }
-}
-async function updateCardElo(courseID, cardID, elo) {
-  if (elo) {
-    const cDB = getCourseDB(courseID);
-    const card = await cDB.get(cardID);
-    logger.debug(`Replacing ${JSON.stringify(card.elo)} with ${JSON.stringify(elo)}`);
-    card.elo = elo;
-    return cDB.put(card);
-  }
-}
-function getTagID(tagName) {
-  const tagPrefix = "TAG" /* TAG */.valueOf() + "-";
-  if (tagName.indexOf(tagPrefix) === 0) {
-    return tagName;
-  } else {
-    return tagPrefix + tagName;
-  }
-}
 function getCourseDB(courseID) {
   const dbName = `coursedb-${courseID}`;
   return new pouchdb_setup_default(
@@ -526,7 +423,7 @@ function getCourseDB(courseID) {
     pouchDBincludeCredentialsConfig
   );
 }
-var import_common, import_common2, import_common3, AlreadyTaggedErr;
+var import_common, import_common2, import_common3, import_uuid;
 var init_courseAPI = __esm({
   "src/impl/couch/courseAPI.ts"() {
     "use strict";
@@ -540,12 +437,7 @@ var init_courseAPI = __esm({
     import_common3 = require("@vue-skuilder/common");
     init_common();
     init_logger();
-    AlreadyTaggedErr = class extends Error {
-      constructor(message) {
-        super(message);
-        this.name = "AlreadyTaggedErr";
-      }
-    };
+    import_uuid = require("uuid");
   }
 });
 
@@ -680,82 +572,7 @@ var init_navigators = __esm({
 });
 
 // src/impl/couch/courseDB.ts
-function randIntWeightedTowardZero(n) {
-  return Math.floor(Math.random() * Math.random() * Math.random() * n);
-}
-async function getCourseTagStubs(courseID) {
-  logger.debug(`Getting tag stubs for course: ${courseID}`);
-  const stubs = await filterAllDocsByPrefix2(
-    getCourseDB2(courseID),
-    "TAG" /* TAG */.valueOf() + "-"
-  );
-  stubs.rows.forEach((row) => {
-    logger.debug(`	Tag stub for doc: ${row.id}`);
-  });
-  return stubs;
-}
-async function createTag(courseID, tagName, author) {
-  logger.debug(`Creating tag: ${tagName}...`);
-  const tagID = getTagID(tagName);
-  const courseDB = getCourseDB2(courseID);
-  const resp = await courseDB.put({
-    course: courseID,
-    docType: "TAG" /* TAG */,
-    name: tagName,
-    snippet: "",
-    taggedCards: [],
-    wiki: "",
-    author,
-    _id: tagID
-  });
-  return resp;
-}
-async function updateTag(tag) {
-  const prior = await getTag(tag.course, tag.name);
-  return await getCourseDB2(tag.course).put({
-    ...tag,
-    _rev: prior._rev
-  });
-}
-async function getTag(courseID, tagName) {
-  const tagID = getTagID(tagName);
-  const courseDB = getCourseDB2(courseID);
-  return courseDB.get(tagID);
-}
-async function removeTagFromCard(courseID, cardID, tagID) {
-  tagID = getTagID(tagID);
-  const courseDB = getCourseDB2(courseID);
-  const tag = await courseDB.get(tagID);
-  tag.taggedCards = tag.taggedCards.filter((taggedID) => {
-    return cardID !== taggedID;
-  });
-  return courseDB.put(tag);
-}
-async function getAppliedTags(id_course, id_card) {
-  const db = getCourseDB2(id_course);
-  const result = await db.query("getTags", {
-    startkey: id_card,
-    endkey: id_card
-    // include_docs: true
-  });
-  return result;
-}
-async function updateCredentialledCourseConfig(courseID, config) {
-  logger.debug(`Updating course config:
-
-${JSON.stringify(config)}
-`);
-  const db = getCourseDB2(courseID);
-  const old = await getCredentialledCourseConfig(courseID);
-  return await db.put({
-    ...config,
-    _rev: old._rev
-  });
-}
-function isSuccessRow(row) {
-  return "doc" in row && row.doc !== null && row.doc !== void 0;
-}
-var import_common5, CourseDB;
+var import_common5;
 var init_courseDB = __esm({
   "src/impl/couch/courseDB.ts"() {
     "use strict";
@@ -768,428 +585,17 @@ var init_courseDB = __esm({
     init_courseAPI();
     init_courseLookupDB();
     init_navigators();
-    CourseDB = class {
-      // private log(msg: string): void {
-      //   log(`CourseLog: ${this.id}\n  ${msg}`);
-      // }
-      db;
-      id;
-      _getCurrentUser;
-      updateQueue;
-      constructor(id, userLookup) {
-        this.id = id;
-        this.db = getCourseDB2(this.id);
-        this._getCurrentUser = userLookup;
-        this.updateQueue = new UpdateQueue(this.db);
-      }
-      getCourseID() {
-        return this.id;
-      }
-      async getCourseInfo() {
-        const cardCount = (await this.db.find({
-          selector: {
-            docType: "CARD" /* CARD */
-          },
-          limit: 1e3
-        })).docs.length;
-        return {
-          cardCount,
-          registeredUsers: 0
-        };
-      }
-      async getInexperiencedCards(limit = 2) {
-        return (await this.db.query("cardsByInexperience", {
-          limit
-        })).rows.map((r) => {
-          const ret = {
-            courseId: this.id,
-            cardId: r.id,
-            count: r.key,
-            elo: r.value
-          };
-          return ret;
-        });
-      }
-      async getCardsByEloLimits(options = {
-        low: 0,
-        high: Number.MIN_SAFE_INTEGER,
-        limit: 25,
-        page: 0
-      }) {
-        return (await this.db.query("elo", {
-          startkey: options.low,
-          endkey: options.high,
-          limit: options.limit,
-          skip: options.limit * options.page
-        })).rows.map((r) => {
-          return `${this.id}-${r.id}-${r.key}`;
-        });
-      }
-      async getCardEloData(id) {
-        const docs = await this.db.allDocs({
-          keys: id,
-          include_docs: true
-        });
-        const ret = [];
-        docs.rows.forEach((r) => {
-          if (isSuccessRow(r)) {
-            if (r.doc && r.doc.elo) {
-              ret.push((0, import_common5.toCourseElo)(r.doc.elo));
-            } else {
-              logger.warn("no elo data for card: " + r.id);
-              ret.push((0, import_common5.blankCourseElo)());
-            }
-          } else {
-            logger.warn("no elo data for card: " + JSON.stringify(r));
-            ret.push((0, import_common5.blankCourseElo)());
-          }
-        });
-        return ret;
-      }
-      /**
-       * Returns the lowest and highest `global` ELO ratings in the course
-       */
-      async getELOBounds() {
-        const [low, high] = await Promise.all([
-          (await this.db.query("elo", {
-            startkey: 0,
-            limit: 1,
-            include_docs: false
-          })).rows[0].key,
-          (await this.db.query("elo", {
-            limit: 1,
-            descending: true,
-            startkey: 1e5
-          })).rows[0].key
-        ]);
-        return {
-          low,
-          high
-        };
-      }
-      async removeCard(id) {
-        const doc = await this.db.get(id);
-        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`);
-        }
-        return this.db.remove(doc);
-      }
-      async getCardDisplayableDataIDs(id) {
-        logger.debug(id.join(", "));
-        const cards = await this.db.allDocs({
-          keys: id,
-          include_docs: true
-        });
-        const ret = {};
-        cards.rows.forEach((r) => {
-          if (isSuccessRow(r)) {
-            ret[r.id] = r.doc.id_displayable_data;
-          }
-        });
-        await Promise.all(
-          cards.rows.map((r) => {
-            return async () => {
-              if (isSuccessRow(r)) {
-                ret[r.id] = r.doc.id_displayable_data;
-              }
-            };
-          })
-        );
-        return ret;
-      }
-      async getCardsByELO(elo, cardLimit) {
-        elo = parseInt(elo);
-        const limit = cardLimit ? cardLimit : 25;
-        const below = await this.db.query("elo", {
-          limit: Math.ceil(limit / 2),
-          startkey: elo,
-          descending: true
-        });
-        const aboveLimit = limit - below.rows.length;
-        const above = await this.db.query("elo", {
-          limit: aboveLimit,
-          startkey: elo + 1
-        });
-        let cards = below.rows;
-        cards = cards.concat(above.rows);
-        const ret = cards.sort((a, b) => {
-          const s = Math.abs(a.key - elo) - Math.abs(b.key - elo);
-          if (s === 0) {
-            return Math.random() - 0.5;
-          } else {
-            return s;
-          }
-        }).map((c) => `${this.id}-${c.id}-${c.key}`);
-        const str = `below:
-${below.rows.map((r) => `	${r.id}-${r.key}
-`)}
-
-above:
-${above.rows.map((r) => `	${r.id}-${r.key}
-`)}`;
-        logger.debug(`Getting ${limit} cards centered around elo: ${elo}:
-
-` + str);
-        return ret;
-      }
-      async getCourseConfig() {
-        const ret = await getCredentialledCourseConfig(this.id);
-        if (ret) {
-          return ret;
-        } else {
-          throw new Error(`Course config not found for course ID: ${this.id}`);
-        }
-      }
-      async updateCourseConfig(cfg) {
-        logger.debug(`Updating: ${JSON.stringify(cfg)}`);
-        try {
-          return await updateCredentialledCourseConfig(this.id, cfg);
-        } catch (error) {
-          logger.error(`Error updating course config in course DB: ${error}`);
-          throw error;
-        }
-      }
-      async updateCardElo(cardId, elo) {
-        if (!elo) {
-          throw new Error(`Cannot update card elo with null or undefined value for card ID: ${cardId}`);
-        }
-        try {
-          const result = await this.updateQueue.update(cardId, (card) => {
-            logger.debug(`Replacing ${JSON.stringify(card.elo)} with ${JSON.stringify(elo)}`);
-            card.elo = elo;
-            return card;
-          });
-          return { ok: true, id: cardId, rev: result._rev };
-        } catch (error) {
-          logger.error(`Failed to update card elo for card ID: ${cardId}`, error);
-          throw new Error(`Failed to update card elo for card ID: ${cardId}`);
-        }
-      }
-      async getAppliedTags(cardId) {
-        const ret = await getAppliedTags(this.id, cardId);
-        if (ret) {
-          return ret;
-        } else {
-          throw new Error(`Failed to find tags for card ${this.id}-${cardId}`);
-        }
-      }
-      async addTagToCard(cardId, tagId, updateELO) {
-        return await addTagToCard(this.id, cardId, tagId, (await this._getCurrentUser()).getUsername(), updateELO);
-      }
-      async removeTagFromCard(cardId, tagId) {
-        return await removeTagFromCard(this.id, cardId, tagId);
-      }
-      async createTag(name, author) {
-        return await createTag(this.id, name, author);
-      }
-      async getTag(tagId) {
-        return await getTag(this.id, tagId);
-      }
-      async updateTag(tag) {
-        if (tag.course !== this.id) {
-          throw new Error(`Tag ${JSON.stringify(tag)} does not belong to course ${this.id}`);
-        }
-        return await updateTag(tag);
-      }
-      async getCourseTagStubs() {
-        return getCourseTagStubs(this.id);
-      }
-      async addNote(codeCourse, shape, data, author, tags, uploads, elo = (0, import_common5.blankCourseElo)()) {
-        try {
-          const resp = await addNote55(this.id, codeCourse, shape, data, author, tags, uploads, elo);
-          if (resp.ok) {
-            if (resp.cardCreationFailed) {
-              logger.warn(
-                `[courseDB.addNote] Note added but card creation failed: ${resp.cardCreationError}`
-              );
-              return {
-                status: import_common5.Status.error,
-                message: `Note was added but no cards were created: ${resp.cardCreationError}`,
-                id: resp.id
-              };
-            }
-            return {
-              status: import_common5.Status.ok,
-              message: "",
-              id: resp.id
-            };
-          } else {
-            return {
-              status: import_common5.Status.error,
-              message: "Unexpected error adding note"
-            };
-          }
-        } catch (e) {
-          const err = e;
-          logger.error(
-            `[addNote] error ${err.name}
-	reason: ${err.reason}
-	message: ${err.message}`
-          );
-          return {
-            status: import_common5.Status.error,
-            message: `Error adding note to course. ${e.reason || err.message}`
-          };
-        }
-      }
-      async getCourseDoc(id, options) {
-        return await getCourseDoc(this.id, id, options);
-      }
-      async getCourseDocs(ids, options = {}) {
-        return await getCourseDocs(this.id, ids, options);
-      }
-      ////////////////////////////////////
-      // NavigationStrategyManager implementation
-      ////////////////////////////////////
-      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",
-            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(strategies);
-      }
-      addNavigationStrategy(data) {
-        logger.debug(`[courseDB] Adding navigation strategy: ${data.id}`);
-        logger.debug(JSON.stringify(data));
-        return Promise.resolve();
-      }
-      updateNavigationStrategy(id, data) {
-        logger.debug(`[courseDB] Updating navigation strategy: ${id}`);
-        logger.debug(JSON.stringify(data));
-        return Promise.resolve();
-      }
-      async surfaceNavigationStrategy() {
-        logger.warn(`Returning hard-coded default ELO navigator`);
-        const ret = {
-          id: "ELO",
-          docType: "NAVIGATION_STRATEGY" /* NAVIGATION_STRATEGY */,
-          name: "ELO",
-          description: "ELO-based navigation strategy",
-          implementingClass: "elo" /* ELO */,
-          course: this.id,
-          serializedData: ""
-          // serde is a noop for ELO navigator.
-        };
-        return Promise.resolve(ret);
-      }
-      ////////////////////////////////////
-      // END NavigationStrategyManager implementation
-      ////////////////////////////////////
-      ////////////////////////////////////
-      // StudyContentSource implementation
-      ////////////////////////////////////
-      async getNewCards(limit = 99) {
-        const u = await this._getCurrentUser();
-        try {
-          const strategy = await this.surfaceNavigationStrategy();
-          const navigator = await ContentNavigator.create(u, this, strategy);
-          return navigator.getNewCards(limit);
-        } catch (e) {
-          logger.error(`[courseDB] Error surfacing a NavigationStrategy: ${e}`);
-          throw e;
-        }
-      }
-      async getPendingReviews() {
-        const u = await this._getCurrentUser();
-        try {
-          const strategy = await this.surfaceNavigationStrategy();
-          const navigator = await ContentNavigator.create(u, this, strategy);
-          return navigator.getPendingReviews();
-        } catch (e) {
-          logger.error(`[courseDB] Error surfacing a NavigationStrategy: ${e}`);
-          throw e;
-        }
-      }
-      async getCardsCenteredAtELO(options = {
-        limit: 99,
-        elo: "user"
-      }, filter) {
-        let targetElo;
-        if (options.elo === "user") {
-          const u = await this._getCurrentUser();
-          targetElo = -1;
-          try {
-            const courseDoc = (await u.getCourseRegistrationsDoc()).courses.find((c) => {
-              return c.courseID === this.id;
-            });
-            targetElo = (0, import_common5.EloToNumber)(courseDoc.elo);
-          } catch {
-            targetElo = 1e3;
-          }
-        } else if (options.elo === "random") {
-          const bounds = await GET_CACHED(`elo-bounds-${this.id}`, () => this.getELOBounds());
-          targetElo = Math.round(bounds.low + Math.random() * (bounds.high - bounds.low));
-        } else {
-          targetElo = options.elo;
-        }
-        let cards = [];
-        let mult = 4;
-        let previousCount = -1;
-        let newCount = 0;
-        while (cards.length < options.limit && newCount !== previousCount) {
-          cards = await this.getCardsByELO(targetElo, mult * options.limit);
-          previousCount = newCount;
-          newCount = cards.length;
-          logger.debug(`Found ${cards.length} elo neighbor cards...`);
-          if (filter) {
-            cards = cards.filter(filter);
-            logger.debug(`Filtered to ${cards.length} cards...`);
-          }
-          mult *= 2;
-        }
-        const selectedCards = [];
-        while (selectedCards.length < options.limit && cards.length > 0) {
-          const index = randIntWeightedTowardZero(cards.length);
-          const card = cards.splice(index, 1)[0];
-          selectedCards.push(card);
-        }
-        return selectedCards.map((c) => {
-          const split = c.split("-");
-          return {
-            courseID: this.id,
-            cardID: split[1],
-            qualifiedID: `${split[0]}-${split[1]}`,
-            contentSourceType: "course",
-            contentSourceID: this.id,
-            status: "new"
-          };
-        });
-      }
-    };
   }
 });
 
 // src/impl/couch/classroomDB.ts
-var import_moment2;
+var import_moment3;
 var init_classroomDB2 = __esm({
   "src/impl/couch/classroomDB.ts"() {
     "use strict";
     init_factory();
     init_logger();
-    import_moment2 = __toESM(require("moment"));
+    import_moment3 = __toESM(require("moment"));
     init_pouchdb_setup();
     init_couch();
     init_courseDB();
@@ -1236,45 +642,13 @@ var init_CouchDBSyncStrategy = __esm({
 });
 
 // src/impl/couch/index.ts
-function getCourseDB2(courseID) {
-  return new pouchdb_setup_default(
-    ENV.COUCHDB_SERVER_PROTOCOL + "://" + ENV.COUCHDB_SERVER_URL + "coursedb-" + courseID,
-    pouchDBincludeCredentialsConfig
-  );
-}
-function getCourseDocs(courseID, docIDs, options = {}) {
-  return getCourseDB2(courseID).allDocs({
-    ...options,
-    keys: docIDs
-  });
-}
-function getCourseDoc(courseID, docID, options = {}) {
-  return getCourseDB2(courseID).get(docID, options);
-}
-function filterAllDocsByPrefix2(db, prefix, opts) {
-  const options = {
-    startkey: prefix,
-    endkey: prefix + "\uFFF0",
-    include_docs: true
-  };
-  if (opts) {
-    Object.assign(options, opts);
-  }
-  return db.allDocs(options);
-}
-function getStartAndEndKeys2(key) {
-  return {
-    startkey: key,
-    endkey: key + "\uFFF0"
-  };
-}
-var import_moment3, import_process, isBrowser, GUEST_LOCAL_DB, localUserDB, pouchDBincludeCredentialsConfig, REVIEW_PREFIX2, REVIEW_TIME_FORMAT2;
+var import_moment4, import_process, isBrowser, GUEST_LOCAL_DB, localUserDB, pouchDBincludeCredentialsConfig;
 var init_couch = __esm({
   "src/impl/couch/index.ts"() {
     "use strict";
     init_factory();
     init_types_legacy();
-    import_moment3 = __toESM(require("moment"));
+    import_moment4 = __toESM(require("moment"));
     init_logger();
     init_pouchdb_setup();
     import_process = __toESM(require("process"));
@@ -1296,75 +670,6 @@ 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
-var import_moment4, UsrCrsData;
-var init_user_course_relDB = __esm({
-  "src/impl/couch/user-course-relDB.ts"() {
-    "use strict";
-    import_moment4 = __toESM(require("moment"));
-    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 = import_moment4.default.utc().add(daysCount, "days");
-        return this.getReviewstoDate(time);
-      }
-      async getPendingReviews() {
-        const now = import_moment4.default.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 = import_moment4.default.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);
-      }
-    };
   }
 });
 
@@ -1461,10 +766,11 @@ async function dropUserFromClassroom(user, classID) {
 async function getUserClassrooms(user) {
   return getOrCreateClassroomRegistrationsDoc(user);
 }
-var import_common8, import_moment5, log3, cardHistoryPrefix2, BaseUser, userCoursesDoc, userClassroomsDoc;
+var import_common8, import_moment5, log3, BaseUser, userCoursesDoc, userClassroomsDoc;
 var init_BaseUserDB = __esm({
   "src/impl/common/BaseUserDB.ts"() {
     "use strict";
+    init_core();
     init_util();
     import_common8 = require("@vue-skuilder/common");
     import_moment5 = __toESM(require("moment"));
@@ -1477,7 +783,6 @@ var init_BaseUserDB = __esm({
     log3 = (s) => {
       logger.info(s);
     };
-    cardHistoryPrefix2 = "cardH-";
     BaseUser = class _BaseUser {
       static _instance;
       static _initialized = false;
@@ -1498,11 +803,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()) {
@@ -1566,8 +873,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;
@@ -1636,7 +943,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,
@@ -1708,7 +1015,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,
@@ -1718,8 +1025,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 = import_moment5.default.utc(r.id.substr(REVIEW_PREFIX.length), REVIEW_TIME_FORMAT);
+          if (r.id.startsWith(DocTypePrefixes["SCHEDULED_CARD" /* SCHEDULED_CARD */])) {
+            const date = import_moment5.default.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;
@@ -1834,7 +1144,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);
@@ -1907,7 +1218,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;
@@ -2025,8 +1337,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}
@@ -2061,7 +1373,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);
                 log3(`Successfully removed duplicate review: ${docId}`);
               } catch (error) {
                 log3(`Failed to remove duplicate review ${docId}: ${error}`);
@@ -2083,7 +1395,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;
         }
@@ -2092,8 +1404,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;
@@ -2105,7 +1417,7 @@ Currently logged-in as ${this._username}.`
       async getHistory() {
         const cards = await filterAllDocsByPrefix(
           this.remoteDB,
-          cardHistoryPrefix2,
+          DocTypePrefixes["CARDRECORD" /* CARDRECORD */],
           {
             include_docs: true,
             attachments: false
@@ -2146,7 +1458,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: []
             });
@@ -2194,10 +1506,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);
@@ -2428,18 +1740,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) {
@@ -2449,21 +1764,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) {
@@ -2484,6 +1786,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
@@ -2727,6 +2030,7 @@ var init_courseDB3 = __esm({
     import_common11 = require("@vue-skuilder/common");
     init_types_legacy();
     init_navigators();
+    init_logger();
     StaticCourseDB = class {
       constructor(courseId, unpacker, userDB, manifest) {
         this.courseId = courseId;
@@ -2748,10 +2052,11 @@ var init_courseDB3 = __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) {
@@ -2840,12 +2145,56 @@ var init_courseDB3 = __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");
@@ -2863,11 +2212,69 @@ var init_courseDB3 = __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 {
@@ -2973,6 +2380,9 @@ var init_NoOpSyncStrategy = __esm({
       setupRemoteDB(username) {
         return getLocalUserDB(username);
       }
+      getWriteDB(username) {
+        return getLocalUserDB(username);
+      }
       startSync(_localDB, _remoteDB) {
       }
       stopSync() {