@vue-skuilder/db 0.1.7 → 0.1.8-0

package/dist/impl/couch/index.js

@@ -42,6 +42,20 @@ var init_SyncStrategy = __esm({
   }
 });
 
+// src/core/interfaces/adminDB.ts
+var init_adminDB = __esm({
+  "src/core/interfaces/adminDB.ts"() {
+    "use strict";
+  }
+});
+
+// src/core/interfaces/classroomDB.ts
+var init_classroomDB = __esm({
+  "src/core/interfaces/classroomDB.ts"() {
+    "use strict";
+  }
+});
+
 // src/util/logger.ts
 var isDevelopment, logger;
 var init_logger = __esm({
@@ -87,31 +101,6 @@ var init_logger = __esm({
   }
 });
 
-// src/core/types/types-legacy.ts
-var GuestUsername, log, cardHistoryPrefix;
-var init_types_legacy = __esm({
-  "src/core/types/types-legacy.ts"() {
-    "use strict";
-    init_logger();
-    GuestUsername = "Guest";
-    log = (message) => {
-      logger.log(message);
-    };
-    cardHistoryPrefix = "cardH";
-  }
-});
-
-// src/core/util/index.ts
-function getCardHistoryID(courseID, cardID) {
-  return `${cardHistoryPrefix}-${courseID}-${cardID}`;
-}
-var init_util = __esm({
-  "src/core/util/index.ts"() {
-    "use strict";
-    init_types_legacy();
-  }
-});
-
 // src/impl/couch/pouchdb-setup.ts
 var import_pouchdb, import_pouchdb_find, import_pouchdb_authentication, pouchdb_setup_default;
 var init_pouchdb_setup = __esm({
@@ -131,123 +120,6 @@ var init_pouchdb_setup = __esm({
   }
 });
 
-// src/util/tuiLogger.ts
-var init_tuiLogger = __esm({
-  "src/util/tuiLogger.ts"() {
-    "use strict";
-    init_dataDirectory();
-  }
-});
-
-// src/util/dataDirectory.ts
-function getAppDataDirectory() {
-  return path.join(os.homedir(), ".tuilder");
-}
-function getDbPath(dbName) {
-  return path.join(getAppDataDirectory(), dbName);
-}
-var path, os;
-var init_dataDirectory = __esm({
-  "src/util/dataDirectory.ts"() {
-    "use strict";
-    path = __toESM(require("path"));
-    os = __toESM(require("os"));
-    init_tuiLogger();
-  }
-});
-
-// src/impl/common/userDBHelpers.ts
-function hexEncode(str) {
-  let hex;
-  let returnStr = "";
-  for (let i = 0; i < str.length; i++) {
-    hex = str.charCodeAt(i).toString(16);
-    returnStr += ("000" + hex).slice(3);
-  }
-  return returnStr;
-}
-function filterAllDocsByPrefix(db, prefix, opts) {
-  const options = {
-    startkey: prefix,
-    endkey: prefix + "\uFFF0",
-    include_docs: true
-  };
-  if (opts) {
-    Object.assign(options, opts);
-  }
-  return db.allDocs(options);
-}
-function getStartAndEndKeys(key) {
-  return {
-    startkey: key,
-    endkey: key + "\uFFF0"
-  };
-}
-function updateGuestAccountExpirationDate(guestDB) {
-  const currentTime = import_moment.default.utc();
-  const expirationDate = currentTime.add(2, "months").toISOString();
-  const expiryDocID2 = "GuestAccountExpirationDate";
-  void guestDB.get(expiryDocID2).then((doc) => {
-    return guestDB.put({
-      _id: expiryDocID2,
-      _rev: doc._rev,
-      date: expirationDate
-    });
-  }).catch(() => {
-    return guestDB.put({
-      _id: expiryDocID2,
-      date: expirationDate
-    });
-  });
-}
-function getLocalUserDB(username) {
-  const dbName = `userdb-${username}`;
-  if (typeof window === "undefined") {
-    return new pouchdb_setup_default(getDbPath(dbName), {});
-  } else {
-    return new pouchdb_setup_default(dbName, {});
-  }
-}
-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),
-    cardId: review.card_id,
-    reviewTime: review.time,
-    courseId: review.course_id,
-    scheduledAt: now,
-    scheduledFor: review.scheduledFor,
-    schedulingAgentId: review.schedulingAgentId
-  });
-}
-async function removeScheduledCardReviewLocal(userDB, reviewDocID) {
-  const reviewDoc = await userDB.get(reviewDocID);
-  userDB.remove(reviewDoc).then((res) => {
-    if (res.ok) {
-      log2(`Removed Review Doc: ${reviewDocID}`);
-    }
-  }).catch((err) => {
-    log2(`Failed to remove Review Doc: ${reviewDocID},
-${JSON.stringify(err)}`);
-  });
-}
-var import_moment, REVIEW_PREFIX, REVIEW_TIME_FORMAT, log2;
-var init_userDBHelpers = __esm({
-  "src/impl/common/userDBHelpers.ts"() {
-    "use strict";
-    import_moment = __toESM(require("moment"));
-    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);
-    };
-  }
-});
-
 // src/util/Loggable.ts
 var Loggable;
 var init_Loggable = __esm({
@@ -275,7 +147,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]) {
@@ -285,24 +160,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];
@@ -315,7 +191,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;
@@ -341,6 +217,32 @@ var init_updateQueue = __esm({
   }
 });
 
+// src/core/types/types-legacy.ts
+var GuestUsername, log, DocTypePrefixes;
+var init_types_legacy = __esm({
+  "src/core/types/types-legacy.ts"() {
+    "use strict";
+    init_logger();
+    GuestUsername = "Guest";
+    log = (message) => {
+      logger.log(message);
+    };
+    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/impl/couch/clientCache.ts
 async function GET_CACHED(k, f) {
   if (CLIENT_CACHE[k]) {
@@ -364,7 +266,8 @@ var init_clientCache = __esm({
 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 _id = `${DocTypePrefixes["DISPLAYABLE_DATA" /* DISPLAYABLE_DATA */]}-${(0, import_uuid.v4)()}`;
+  const result = await db.put({ ...payload, _id });
   const dataShapeId = import_common.NameSpacer.getDataShapeString({
     course: codeCourse,
     dataShape: shape.name
@@ -435,7 +338,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 */]}-${(0, import_uuid.v4)()}`;
+  const card = await db.put({
+    _id,
     course,
     id_displayable_data,
     id_view,
@@ -528,7 +433,7 @@ function getCourseDB(courseID) {
     pouchDBincludeCredentialsConfig
   );
 }
-var import_common, import_common2, import_common3, AlreadyTaggedErr;
+var import_common, import_common2, import_common3, import_uuid, AlreadyTaggedErr;
 var init_courseAPI = __esm({
   "src/impl/couch/courseAPI.ts"() {
     "use strict";
@@ -542,6 +447,7 @@ var init_courseAPI = __esm({
     import_common3 = require("@vue-skuilder/common");
     init_common();
     init_logger();
+    import_uuid = require("uuid");
     AlreadyTaggedErr = class extends Error {
       constructor(message) {
         super(message);
@@ -811,7 +717,7 @@ async function getCourseQuestionTypes(courseID) {
 }
 async function getCourseTagStubs(courseID) {
   logger.debug(`Getting tag stubs for course: ${courseID}`);
-  const stubs = await filterAllDocsByPrefix2(
+  const stubs = await filterAllDocsByPrefix(
     getCourseDB2(courseID),
     "TAG" /* TAG */.valueOf() + "-"
   );
@@ -876,7 +782,7 @@ function getAncestorTagIDs(courseID, tagID) {
   }
 }
 async function getChildTagStubs(courseID, tagID) {
-  return await filterAllDocsByPrefix2(getCourseDB2(courseID), tagID + ">");
+  return await filterAllDocsByPrefix(getCourseDB2(courseID), tagID + ">");
 }
 async function getAppliedTags(id_course, id_card) {
   const db = getCourseDB2(id_course);
@@ -1383,1217 +1289,1420 @@ ${above.rows.map((r) => `	${r.id}-${r.key}
   }
 });
 
-// src/impl/couch/user-course-relDB.ts
-var import_moment2, UsrCrsData;
-var init_user_course_relDB = __esm({
-  "src/impl/couch/user-course-relDB.ts"() {
+// src/impl/couch/classroomDB.ts
+function getClassroomDB(classID, version) {
+  const dbName = `classdb-${version}-${classID}`;
+  logger.info(`Retrieving classroom db: ${dbName}`);
+  return new pouchdb_setup_default(
+    ENV.COUCHDB_SERVER_PROTOCOL + "://" + ENV.COUCHDB_SERVER_URL + dbName,
+    pouchDBincludeCredentialsConfig
+  );
+}
+async function getClassroomConfig(classID) {
+  return await getClassroomDB(classID, "student").get(CLASSROOM_CONFIG);
+}
+var import_moment, classroomLookupDBTitle, CLASSROOM_CONFIG, ClassroomDBBase, StudentClassroomDB, TeacherClassroomDB, ClassroomLookupDB;
+var init_classroomDB2 = __esm({
+  "src/impl/couch/classroomDB.ts"() {
     "use strict";
-    import_moment2 = __toESM(require("moment"));
+    init_factory();
+    init_logger();
+    import_moment = __toESM(require("moment"));
+    init_pouchdb_setup();
     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_moment2.default.utc().add(daysCount, "days");
-        return this.getReviewstoDate(time);
-      }
-      async getPendingReviews() {
-        const now = import_moment2.default.utc();
-        return this.getReviewstoDate(now);
+    classroomLookupDBTitle = "classdb-lookup";
+    CLASSROOM_CONFIG = "ClassroomConfig";
+    ClassroomDBBase = class {
+      _id;
+      _db;
+      _cfg;
+      _initComplete = false;
+      _content_prefix = "content";
+      get _content_searchkeys() {
+        return getStartAndEndKeys(this._content_prefix);
       }
-      async getScheduledReviewCount() {
-        return (await this.getPendingReviews()).length;
+      async getAssignedContent() {
+        logger.info(`Getting assigned content...`);
+        const docRows = await this._db.allDocs({
+          startkey: this._content_prefix,
+          endkey: this._content_prefix + `\uFFF0`,
+          include_docs: true
+        });
+        const ret = docRows.rows.map((row) => {
+          return row.doc;
+        });
+        return ret;
       }
-      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;
+      getContentId(content) {
+        if (content.type === "tag") {
+          return `${this._content_prefix}-${content.courseID}-${content.tagID}`;
         } else {
-          logger.warn(`no settings found during lookup on course ${this._courseId}`);
-          return {};
+          return `${this._content_prefix}-${content.courseID}`;
         }
       }
-      updateCourseSettings(updates) {
-        void this.user.updateCourseSettings(this._courseId, updates);
+      get ready() {
+        return this._initComplete;
       }
-      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_moment2.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);
+      getConfig() {
+        return this._cfg;
       }
     };
-  }
-});
-
-// src/impl/common/BaseUserDB.ts
-async function getOrCreateClassroomRegistrationsDoc(user) {
-  let ret;
-  try {
-    ret = await getLocalUserDB(user).get(userClassroomsDoc);
-  } catch (e) {
-    const err = e;
-    if (err.status === 404) {
-      await getLocalUserDB(user).put({
-        _id: userClassroomsDoc,
-        registrations: []
-      });
-      ret = await getOrCreateClassroomRegistrationsDoc(user);
-    } else {
-      const errorDetails = {
-        name: err.name,
-        status: err.status,
-        message: err.message,
-        reason: err.reason,
-        error: err.error
-      };
-      logger.error(
-        "Database error in getOrCreateClassroomRegistrationsDoc (standalone function):",
-        errorDetails
-      );
-      throw new Error(
-        `Database error accessing classroom registrations: ${err.message || err.name || "Unknown error"} (status: ${err.status})`
-      );
-    }
-  }
-  return ret;
-}
-async function getOrCreateCourseRegistrationsDoc(user) {
-  let ret;
-  try {
-    ret = await getLocalUserDB(user).get(userCoursesDoc);
-  } catch (e) {
-    const err = e;
-    if (err.status === 404) {
-      await getLocalUserDB(user).put({
-        _id: userCoursesDoc,
-        courses: [],
-        studyWeight: {}
-      });
-      ret = await getOrCreateCourseRegistrationsDoc(user);
-    } else {
-      throw new Error(
-        `Unexpected error ${JSON.stringify(e)} in getOrCreateCourseRegistrationDoc...`
-      );
-    }
-  }
-  return ret;
-}
-async function updateUserElo(user, course_id, elo) {
-  const regDoc = await getOrCreateCourseRegistrationsDoc(user);
-  const course = regDoc.courses.find((c) => c.courseID === course_id);
-  course.elo = elo;
-  return getLocalUserDB(user).put(regDoc);
-}
-async function registerUserForClassroom(user, classID, registerAs) {
-  log3(`Registering user: ${user} in course: ${classID}`);
-  return getOrCreateClassroomRegistrationsDoc(user).then((doc) => {
-    const regItem = {
-      classID,
-      registeredAs: registerAs
-    };
-    if (doc.registrations.filter((reg) => {
-      return reg.classID === regItem.classID && reg.registeredAs === regItem.registeredAs;
-    }).length === 0) {
-      doc.registrations.push(regItem);
-    } else {
-      log3(`User ${user} is already registered for class ${classID}`);
-    }
-    return getLocalUserDB(user).put(doc);
-  });
-}
-async function dropUserFromClassroom(user, classID) {
-  return getOrCreateClassroomRegistrationsDoc(user).then((doc) => {
-    let index = -1;
-    for (let i = 0; i < doc.registrations.length; i++) {
-      if (doc.registrations[i].classID === classID) {
-        index = i;
-      }
-    }
-    if (index !== -1) {
-      doc.registrations.splice(index, 1);
-    }
-    return getLocalUserDB(user).put(doc);
-  });
-}
-async function getUserClassrooms(user) {
-  return getOrCreateClassroomRegistrationsDoc(user);
-}
-var import_common6, import_moment3, log3, cardHistoryPrefix2, BaseUser, userCoursesDoc, userClassroomsDoc;
-var init_BaseUserDB = __esm({
-  "src/impl/common/BaseUserDB.ts"() {
-    "use strict";
-    init_util();
-    import_common6 = require("@vue-skuilder/common");
-    import_moment3 = __toESM(require("moment"));
-    init_types_legacy();
-    init_logger();
-    init_userDBHelpers();
-    init_updateQueue();
-    init_user_course_relDB();
-    init_couch();
-    log3 = (s) => {
-      logger.info(s);
-    };
-    cardHistoryPrefix2 = "cardH-";
-    BaseUser = class _BaseUser {
-      static _instance;
-      static _initialized = false;
-      static Dummy(syncStrategy) {
-        return new _BaseUser("Me", syncStrategy);
+    StudentClassroomDB = class _StudentClassroomDB extends ClassroomDBBase {
+      // private readonly _prefix: string = 'content';
+      userMessages;
+      _user;
+      constructor(classID, user) {
+        super();
+        this._id = classID;
+        this._user = user;
       }
-      static DOC_IDS = {
-        CONFIG: "CONFIG",
-        COURSE_REGISTRATIONS: "CourseRegistrations",
-        CLASSROOM_REGISTRATIONS: "ClassroomRegistrations"
-      };
-      // private email: string;
-      _username;
-      syncStrategy;
-      getUsername() {
-        return this._username;
+      async init() {
+        const dbName = `classdb-student-${this._id}`;
+        this._db = new pouchdb_setup_default(
+          ENV.COUCHDB_SERVER_PROTOCOL + "://" + ENV.COUCHDB_SERVER_URL + dbName,
+          pouchDBincludeCredentialsConfig
+        );
+        try {
+          const cfg = await this._db.get(CLASSROOM_CONFIG);
+          this._cfg = cfg;
+          this.userMessages = this._db.changes({
+            since: "now",
+            live: true,
+            include_docs: true
+          });
+          this._initComplete = true;
+          return;
+        } catch (e) {
+          throw new Error(`Error in StudentClassroomDB constructor: ${JSON.stringify(e)}`);
+        }
       }
-      isLoggedIn() {
-        return !this._username.startsWith(GuestUsername);
+      static async factory(classID, user) {
+        const ret = new _StudentClassroomDB(classID, user);
+        await ret.init();
+        return ret;
       }
-      remoteDB;
-      remote() {
-        return this.remoteDB;
+      setChangeFcn(f) {
+        void this.userMessages.on("change", f);
       }
-      localDB;
-      updateQueue;
-      async createAccount(username, password) {
-        if (!this.syncStrategy.canCreateAccount()) {
-          throw new Error("Account creation not supported by current sync strategy");
-        }
-        if (!this._username.startsWith(GuestUsername)) {
-          throw new Error(
-            `Cannot create a new account while logged in:
-Currently logged-in as ${this._username}.`
-          );
-        }
-        const result = await this.syncStrategy.createAccount(username, password);
-        if (result.status === import_common6.Status.ok) {
-          log3(`Account created successfully, updating username to ${username}`);
-          this._username = username;
-          try {
-            localStorage.removeItem("dbUUID");
-          } catch (e) {
-            logger.warn("localStorage not available (Node.js environment):", e);
-          }
-          await this.init();
-        }
-        return {
-          status: result.status,
-          error: result.error || ""
-        };
+      async getPendingReviews() {
+        const u = this._user;
+        return (await u.getPendingReviews()).filter((r) => r.scheduledFor === "classroom" && r.schedulingAgentId === this._id).map((r) => {
+          return {
+            ...r,
+            qualifiedID: `${r.courseId}-${r.cardId}`,
+            courseID: r.courseId,
+            cardID: r.cardId,
+            contentSourceType: "classroom",
+            contentSourceID: this._id,
+            reviewID: r._id,
+            status: "review"
+          };
+        });
       }
-      async login(username, password) {
-        if (!this.syncStrategy.canAuthenticate()) {
-          throw new Error("Authentication not supported by current sync strategy");
-        }
-        if (!this._username.startsWith(GuestUsername) && this._username != username) {
-          if (this._username != username) {
-            throw new Error(`Cannot change accounts while logged in.
-        Log out of account ${this.getUsername()} before logging in as ${username}.`);
+      async getNewCards() {
+        const activeCards = await this._user.getActiveCards();
+        const now = import_moment.default.utc();
+        const assigned = await this.getAssignedContent();
+        const due = assigned.filter((c) => now.isAfter(import_moment.default.utc(c.activeOn, REVIEW_TIME_FORMAT)));
+        logger.info(`Due content: ${JSON.stringify(due)}`);
+        let ret = [];
+        for (let i = 0; i < due.length; i++) {
+          const content = due[i];
+          if (content.type === "course") {
+            const db = new CourseDB(content.courseID, async () => this._user);
+            ret = ret.concat(await db.getNewCards());
+          } else if (content.type === "tag") {
+            const tagDoc = await getTag(content.courseID, content.tagID);
+            ret = ret.concat(
+              tagDoc.taggedCards.map((c) => {
+                return {
+                  courseID: content.courseID,
+                  cardID: c,
+                  qualifiedID: `${content.courseID}-${c}`,
+                  contentSourceType: "classroom",
+                  contentSourceID: this._id,
+                  status: "new"
+                };
+              })
+            );
+          } else if (content.type === "card") {
+            ret.push(await getCourseDB2(content.courseID).get(content.cardID));
           }
-          logger.warn(`User ${this._username} is already logged in, but executing login again.`);
         }
-        const loginResult = await this.syncStrategy.authenticate(username, password);
-        if (loginResult.ok) {
-          log3(`Logged in as ${username}`);
-          this._username = username;
-          try {
-            localStorage.removeItem("dbUUID");
-          } catch (e) {
-            logger.warn("localStorage not available (Node.js environment):", e);
+        logger.info(`New Cards from classroom ${this._cfg.name}: ${ret.map((c) => c.qualifiedID)}`);
+        return ret.filter((c) => {
+          if (activeCards.some((ac) => c.qualifiedID.includes(ac))) {
+            return false;
+          } else {
+            return true;
           }
-          await this.init();
-        }
-        return loginResult;
+        });
       }
-      async resetUserData() {
-        if (this.syncStrategy.canAuthenticate()) {
-          return {
-            status: import_common6.Status.error,
-            error: "Reset user data is only available for local-only mode. Use logout instead for remote sync."
-          };
-        }
-        try {
-          const localDB = getLocalUserDB(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
-            id === _BaseUser.DOC_IDS.COURSE_REGISTRATIONS || // Course registrations
-            id === _BaseUser.DOC_IDS.CLASSROOM_REGISTRATIONS || // Classroom registrations
-            id === _BaseUser.DOC_IDS.CONFIG;
-          }).map((row) => ({ _id: row.id, _rev: row.value.rev, _deleted: true }));
-          if (docsToDelete.length > 0) {
-            await localDB.bulkDocs(docsToDelete);
-          }
-          await this.init();
-          return { status: import_common6.Status.ok };
-        } catch (error) {
-          logger.error("Failed to reset user data:", error);
-          return {
-            status: import_common6.Status.error,
-            error: error instanceof Error ? error.message : "Unknown error during reset"
-          };
-        }
-      }
-      async logout() {
-        if (!this.syncStrategy.canAuthenticate()) {
-          this._username = await this.syncStrategy.getCurrentUsername();
-          await this.init();
-          return { ok: true };
-        }
-        const ret = await this.syncStrategy.logout();
-        this._username = await this.syncStrategy.getCurrentUsername();
-        await this.init();
-        return ret;
-      }
-      update(id, update) {
-        return this.updateQueue.update(id, update);
+    };
+    TeacherClassroomDB = class _TeacherClassroomDB extends ClassroomDBBase {
+      _stuDb;
+      constructor(classID) {
+        super();
+        this._id = classID;
       }
-      async getCourseRegistrationsDoc() {
-        logger.debug(`Fetching courseRegistrations for ${this.getUsername()}`);
-        let ret;
+      async init() {
+        const dbName = `classdb-teacher-${this._id}`;
+        const stuDbName = `classdb-student-${this._id}`;
+        this._db = new pouchdb_setup_default(
+          ENV.COUCHDB_SERVER_PROTOCOL + "://" + ENV.COUCHDB_SERVER_URL + dbName,
+          pouchDBincludeCredentialsConfig
+        );
+        this._stuDb = new pouchdb_setup_default(
+          ENV.COUCHDB_SERVER_PROTOCOL + "://" + ENV.COUCHDB_SERVER_URL + stuDbName,
+          pouchDBincludeCredentialsConfig
+        );
         try {
-          const regDoc = await this.localDB.get(
-            _BaseUser.DOC_IDS.COURSE_REGISTRATIONS
-          );
-          return regDoc;
+          return this._db.get(CLASSROOM_CONFIG).then((cfg) => {
+            this._cfg = cfg;
+            this._initComplete = true;
+          }).then(() => {
+            return;
+          });
         } catch (e) {
-          const err = e;
-          if (err.status === 404) {
-            await this.localDB.put({
-              _id: _BaseUser.DOC_IDS.COURSE_REGISTRATIONS,
-              courses: [],
-              studyWeight: {}
-            });
-            ret = await this.getCourseRegistrationsDoc();
-          } else {
-            throw new Error(
-              `Unexpected error ${JSON.stringify(e)} in getOrCreateCourseRegistrationDoc...`
-            );
-          }
+          throw new Error(`Error in TeacherClassroomDB constructor: ${JSON.stringify(e)}`);
         }
-        return ret;
       }
-      async getActiveCourses() {
-        const reg = await this.getCourseRegistrationsDoc();
-        return reg.courses.filter((c) => {
-          return c.status === void 0 || c.status === "active";
-        });
-      }
-      /**
-       * Returns a promise of the card IDs that the user has
-       * a scheduled review for.
-       *
-       */
-      async getActiveCards() {
-        const keys = getStartAndEndKeys(REVIEW_PREFIX);
-        const reviews = await this.remoteDB.allDocs({
-          startkey: keys.startkey,
-          endkey: keys.endkey,
-          include_docs: true
-        });
-        return reviews.rows.map((r) => `${r.doc.courseId}-${r.doc.cardId}`);
+      static async factory(classID) {
+        const ret = new _TeacherClassroomDB(classID);
+        await ret.init();
+        return ret;
       }
-      async getActivityRecords() {
+      async removeContent(content) {
+        const contentID = this.getContentId(content);
         try {
-          const hist = await this.getHistory();
-          const allRecords = [];
-          if (!Array.isArray(hist)) {
-            logger.error("getHistory did not return an array:", hist);
-            return allRecords;
-          }
-          let sampleCount = 0;
-          for (let i = 0; i < hist.length; i++) {
-            try {
-              if (hist[i] && Array.isArray(hist[i].records)) {
-                hist[i].records.forEach((record) => {
-                  try {
-                    if (!record.timeStamp) {
-                      return;
-                    }
-                    let timeStamp;
-                    if (typeof record.timeStamp === "object") {
-                      if (typeof record.timeStamp.toDate === "function") {
-                        timeStamp = record.timeStamp.toISOString();
-                      } else if (record.timeStamp instanceof Date) {
-                        timeStamp = record.timeStamp.toISOString();
-                      } else {
-                        if (sampleCount < 3) {
-                          logger.warn("Unknown timestamp object type:", record.timeStamp);
-                          sampleCount++;
-                        }
-                        return;
-                      }
-                    } else if (typeof record.timeStamp === "string") {
-                      const date = new Date(record.timeStamp);
-                      if (isNaN(date.getTime())) {
-                        return;
-                      }
-                      timeStamp = record.timeStamp;
-                    } else if (typeof record.timeStamp === "number") {
-                      timeStamp = new Date(record.timeStamp).toISOString();
-                    } else {
-                      return;
-                    }
-                    allRecords.push({
-                      timeStamp,
-                      courseID: record.courseID || "unknown",
-                      cardID: record.cardID || "unknown",
-                      timeSpent: record.timeSpent || 0,
-                      type: "card_view"
-                    });
-                  } catch (err) {
-                  }
-                });
-              }
-            } catch (err) {
-              logger.error("Error processing history item:", err);
-            }
-          }
-          logger.debug(`Found ${allRecords.length} activity records`);
-          return allRecords;
-        } catch (err) {
-          logger.error("Error in getActivityRecords:", err);
-          return [];
+          const doc = await this._db.get(contentID);
+          await this._db.remove(doc);
+          void this._db.replicate.to(this._stuDb, {
+            doc_ids: [contentID]
+          });
+        } catch (error) {
+          logger.error("Failed to remove content:", contentID, error);
         }
       }
-      async getReviewstoDate(targetDate, course_id) {
-        const keys = getStartAndEndKeys(REVIEW_PREFIX);
-        const reviews = await this.remoteDB.allDocs({
-          startkey: keys.startkey,
-          endkey: keys.endkey,
-          include_docs: true
-        });
-        log3(
-          `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_moment3.default.utc(r.id.substr(REVIEW_PREFIX.length), REVIEW_TIME_FORMAT);
-            if (targetDate.isAfter(date)) {
-              if (course_id === void 0 || r.doc.courseId === course_id) {
-                return true;
-              }
-            }
-          }
-        }).map((r) => r.doc);
+      async assignContent(content) {
+        let put;
+        const id = this.getContentId(content);
+        if (content.type === "tag") {
+          put = await this._db.put({
+            courseID: content.courseID,
+            tagID: content.tagID,
+            type: "tag",
+            _id: id,
+            assignedBy: content.assignedBy,
+            assignedOn: import_moment.default.utc(),
+            activeOn: content.activeOn || import_moment.default.utc()
+          });
+        } else {
+          put = await this._db.put({
+            courseID: content.courseID,
+            type: "course",
+            _id: id,
+            assignedBy: content.assignedBy,
+            assignedOn: import_moment.default.utc(),
+            activeOn: content.activeOn || import_moment.default.utc()
+          });
+        }
+        if (put.ok) {
+          void this._db.replicate.to(this._stuDb, {
+            doc_ids: [id]
+          });
+          return true;
+        } else {
+          return false;
+        }
+      }
+    };
+    ClassroomLookupDB = () => new pouchdb_setup_default(ENV.COUCHDB_SERVER_PROTOCOL + "://" + ENV.COUCHDB_SERVER_URL + classroomLookupDBTitle, {
+      skip_setup: true
+    });
+  }
+});
+
+// src/core/interfaces/contentSource.ts
+function isReview(item) {
+  const ret = item.status === "review" || item.status === "failed-review" || "reviewID" in item;
+  return ret;
+}
+async function getStudySource(source, user) {
+  if (source.type === "classroom") {
+    return await StudentClassroomDB.factory(source.id, user);
+  } else {
+    return getDataLayer().getCourseDB(source.id);
+  }
+}
+var init_contentSource = __esm({
+  "src/core/interfaces/contentSource.ts"() {
+    "use strict";
+    init_factory();
+    init_classroomDB2();
+  }
+});
+
+// src/core/interfaces/courseDB.ts
+var init_courseDB2 = __esm({
+  "src/core/interfaces/courseDB.ts"() {
+    "use strict";
+  }
+});
+
+// src/core/interfaces/dataLayerProvider.ts
+var init_dataLayerProvider = __esm({
+  "src/core/interfaces/dataLayerProvider.ts"() {
+    "use strict";
+  }
+});
+
+// src/core/interfaces/userDB.ts
+var init_userDB = __esm({
+  "src/core/interfaces/userDB.ts"() {
+    "use strict";
+  }
+});
+
+// src/core/interfaces/index.ts
+var init_interfaces = __esm({
+  "src/core/interfaces/index.ts"() {
+    "use strict";
+    init_adminDB();
+    init_classroomDB();
+    init_contentSource();
+    init_courseDB2();
+    init_dataLayerProvider();
+    init_userDB();
+  }
+});
+
+// src/core/types/user.ts
+var init_user = __esm({
+  "src/core/types/user.ts"() {
+    "use strict";
+  }
+});
+
+// src/core/util/index.ts
+function getCardHistoryID(courseID, cardID) {
+  return `${DocTypePrefixes["CARDRECORD" /* CARDRECORD */]}-${courseID}-${cardID}`;
+}
+var init_util = __esm({
+  "src/core/util/index.ts"() {
+    "use strict";
+    init_types_legacy();
+  }
+});
+
+// src/core/bulkImport/cardProcessor.ts
+var import_common6;
+var init_cardProcessor = __esm({
+  "src/core/bulkImport/cardProcessor.ts"() {
+    "use strict";
+    import_common6 = require("@vue-skuilder/common");
+    init_logger();
+  }
+});
+
+// src/core/bulkImport/types.ts
+var init_types = __esm({
+  "src/core/bulkImport/types.ts"() {
+    "use strict";
+  }
+});
+
+// src/core/bulkImport/index.ts
+var init_bulkImport = __esm({
+  "src/core/bulkImport/index.ts"() {
+    "use strict";
+    init_cardProcessor();
+    init_types();
+  }
+});
+
+// src/core/index.ts
+var init_core = __esm({
+  "src/core/index.ts"() {
+    "use strict";
+    init_interfaces();
+    init_types_legacy();
+    init_user();
+    init_Loggable();
+    init_util();
+    init_navigators();
+    init_bulkImport();
+  }
+});
+
+// src/util/tuiLogger.ts
+var init_tuiLogger = __esm({
+  "src/util/tuiLogger.ts"() {
+    "use strict";
+    init_dataDirectory();
+  }
+});
+
+// src/util/dataDirectory.ts
+function getAppDataDirectory() {
+  return path.join(os.homedir(), ".tuilder");
+}
+function getDbPath(dbName) {
+  return path.join(getAppDataDirectory(), dbName);
+}
+var path, os;
+var init_dataDirectory = __esm({
+  "src/util/dataDirectory.ts"() {
+    "use strict";
+    path = __toESM(require("path"));
+    os = __toESM(require("os"));
+    init_tuiLogger();
+  }
+});
+
+// src/impl/common/userDBHelpers.ts
+function hexEncode(str) {
+  let hex;
+  let returnStr = "";
+  for (let i = 0; i < str.length; i++) {
+    hex = str.charCodeAt(i).toString(16);
+    returnStr += ("000" + hex).slice(3);
+  }
+  return returnStr;
+}
+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"
+  };
+}
+function updateGuestAccountExpirationDate(guestDB) {
+  const currentTime = import_moment2.default.utc();
+  const expirationDate = currentTime.add(2, "months").toISOString();
+  const expiryDocID2 = "GuestAccountExpirationDate";
+  void guestDB.get(expiryDocID2).then((doc) => {
+    return guestDB.put({
+      _id: expiryDocID2,
+      _rev: doc._rev,
+      date: expirationDate
+    });
+  }).catch(() => {
+    return guestDB.put({
+      _id: expiryDocID2,
+      date: expirationDate
+    });
+  });
+}
+function getLocalUserDB(username) {
+  const dbName = `userdb-${username}`;
+  if (typeof window === "undefined") {
+    return new pouchdb_setup_default(getDbPath(dbName), {});
+  } else {
+    return new pouchdb_setup_default(dbName, {});
+  }
+}
+function scheduleCardReviewLocal(userDB, review) {
+  const now = import_moment2.default.utc();
+  logger.info(`Scheduling for review in: ${review.time.diff(now, "h") / 24} days`);
+  void userDB.put({
+    _id: DocTypePrefixes["SCHEDULED_CARD" /* SCHEDULED_CARD */] + review.time.format(REVIEW_TIME_FORMAT2),
+    cardId: review.card_id,
+    reviewTime: review.time.toISOString(),
+    courseId: review.course_id,
+    scheduledAt: now.toISOString(),
+    scheduledFor: review.scheduledFor,
+    schedulingAgentId: review.schedulingAgentId
+  });
+}
+async function removeScheduledCardReviewLocal(userDB, reviewDocID) {
+  const reviewDoc = await userDB.get(reviewDocID);
+  userDB.remove(reviewDoc).then((res) => {
+    if (res.ok) {
+      log2(`Removed Review Doc: ${reviewDocID}`);
+    }
+  }).catch((err) => {
+    log2(`Failed to remove Review Doc: ${reviewDocID},
+${JSON.stringify(err)}`);
+  });
+}
+var import_moment2, REVIEW_TIME_FORMAT2, log2;
+var init_userDBHelpers = __esm({
+  "src/impl/common/userDBHelpers.ts"() {
+    "use strict";
+    import_moment2 = __toESM(require("moment"));
+    init_core();
+    init_logger();
+    init_pouchdb_setup();
+    init_dataDirectory();
+    REVIEW_TIME_FORMAT2 = "YYYY-MM-DD--kk:mm:ss-SSS";
+    log2 = (s) => {
+      logger.info(s);
+    };
+  }
+});
+
+// src/impl/couch/user-course-relDB.ts
+var import_moment3, UsrCrsData;
+var init_user_course_relDB = __esm({
+  "src/impl/couch/user-course-relDB.ts"() {
+    "use strict";
+    import_moment3 = __toESM(require("moment"));
+    init_logger();
+    UsrCrsData = class {
+      user;
+      _courseId;
+      constructor(user, courseId) {
+        this.user = user;
+        this._courseId = courseId;
       }
       async getReviewsForcast(daysCount) {
         const time = import_moment3.default.utc().add(daysCount, "days");
         return this.getReviewstoDate(time);
       }
-      async getPendingReviews(course_id) {
+      async getPendingReviews() {
         const now = import_moment3.default.utc();
-        return this.getReviewstoDate(now, course_id);
-      }
-      async getScheduledReviewCount(course_id) {
-        return (await this.getPendingReviews(course_id)).length;
+        return this.getReviewstoDate(now);
       }
-      async getRegisteredCourses() {
-        const regDoc = await this.getCourseRegistrationsDoc();
-        return regDoc.courses.filter((c) => {
-          return !c.status || c.status === "active" || c.status === "maintenance-mode";
-        });
+      async getScheduledReviewCount() {
+        return (await this.getPendingReviews()).length;
       }
-      async getCourseRegDoc(courseID) {
-        const regDocs = await this.getCourseRegistrationsDoc();
-        const ret = regDocs.courses.find((c) => c.courseID === courseID);
-        if (ret) {
-          return ret;
+      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 {
-          throw new Error(`Course registration not found for course ID: ${courseID}`);
+          logger.warn(`no settings found during lookup on course ${this._courseId}`);
+          return {};
         }
       }
-      async registerForCourse(course_id, previewMode = false) {
-        return this.getCourseRegistrationsDoc().then((doc) => {
-          const status = previewMode ? "preview" : "active";
-          logger.debug(`Registering for ${course_id} with status: ${status}`);
-          const regItem = {
-            status,
-            courseID: course_id,
-            user: true,
-            admin: false,
-            moderator: false,
-            elo: {
-              global: {
-                score: 1e3,
-                count: 0
-              },
-              tags: {},
-              misc: {}
-            }
-          };
-          if (doc.courses.filter((course) => {
-            return course.courseID === regItem.courseID;
-          }).length === 0) {
-            log3(`It's a new course registration!`);
-            doc.courses.push(regItem);
-            doc.studyWeight[course_id] = 1;
-          } else {
-            doc.courses.forEach((c) => {
-              log3(`Found the previously registered course!`);
-              if (c.courseID === course_id) {
-                c.status = status;
-              }
-            });
-          }
-          return this.localDB.put(doc);
-        }).catch((e) => {
-          log3(`Registration failed because of: ${JSON.stringify(e)}`);
-          throw e;
+      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_moment3.default.utc(review.reviewTime);
+          return targetDate.isAfter(reviewTime);
         });
       }
-      async dropCourse(course_id, dropStatus = "dropped") {
-        return this.getCourseRegistrationsDoc().then((doc) => {
-          let index = -1;
-          for (let i = 0; i < doc.courses.length; i++) {
-            if (doc.courses[i].courseID === course_id) {
-              index = i;
-            }
-          }
-          if (index !== -1) {
-            delete doc.studyWeight[course_id];
-            doc.courses[index].status = dropStatus;
-          } else {
-            throw new Error(
-              `User ${this.getUsername()} is not currently registered for course ${course_id}`
-            );
-          }
-          return this.localDB.put(doc);
-        });
+    };
+  }
+});
+
+// src/impl/common/BaseUserDB.ts
+async function getOrCreateClassroomRegistrationsDoc(user) {
+  let ret;
+  try {
+    ret = await getLocalUserDB(user).get(userClassroomsDoc);
+  } catch (e) {
+    const err = e;
+    if (err.status === 404) {
+      await getLocalUserDB(user).put({
+        _id: userClassroomsDoc,
+        registrations: []
+      });
+      ret = await getOrCreateClassroomRegistrationsDoc(user);
+    } else {
+      const errorDetails = {
+        name: err.name,
+        status: err.status,
+        message: err.message,
+        reason: err.reason,
+        error: err.error
+      };
+      logger.error(
+        "Database error in getOrCreateClassroomRegistrationsDoc (standalone function):",
+        errorDetails
+      );
+      throw new Error(
+        `Database error accessing classroom registrations: ${err.message || err.name || "Unknown error"} (status: ${err.status})`
+      );
+    }
+  }
+  return ret;
+}
+async function getOrCreateCourseRegistrationsDoc(user) {
+  let ret;
+  try {
+    ret = await getLocalUserDB(user).get(userCoursesDoc);
+  } catch (e) {
+    const err = e;
+    if (err.status === 404) {
+      await getLocalUserDB(user).put({
+        _id: userCoursesDoc,
+        courses: [],
+        studyWeight: {}
+      });
+      ret = await getOrCreateCourseRegistrationsDoc(user);
+    } else {
+      throw new Error(
+        `Unexpected error ${JSON.stringify(e)} in getOrCreateCourseRegistrationDoc...`
+      );
+    }
+  }
+  return ret;
+}
+async function updateUserElo(user, course_id, elo) {
+  const regDoc = await getOrCreateCourseRegistrationsDoc(user);
+  const course = regDoc.courses.find((c) => c.courseID === course_id);
+  course.elo = elo;
+  return getLocalUserDB(user).put(regDoc);
+}
+async function registerUserForClassroom(user, classID, registerAs) {
+  log3(`Registering user: ${user} in course: ${classID}`);
+  return getOrCreateClassroomRegistrationsDoc(user).then((doc) => {
+    const regItem = {
+      classID,
+      registeredAs: registerAs
+    };
+    if (doc.registrations.filter((reg) => {
+      return reg.classID === regItem.classID && reg.registeredAs === regItem.registeredAs;
+    }).length === 0) {
+      doc.registrations.push(regItem);
+    } else {
+      log3(`User ${user} is already registered for class ${classID}`);
+    }
+    return getLocalUserDB(user).put(doc);
+  });
+}
+async function dropUserFromClassroom(user, classID) {
+  return getOrCreateClassroomRegistrationsDoc(user).then((doc) => {
+    let index = -1;
+    for (let i = 0; i < doc.registrations.length; i++) {
+      if (doc.registrations[i].classID === classID) {
+        index = i;
+      }
+    }
+    if (index !== -1) {
+      doc.registrations.splice(index, 1);
+    }
+    return getLocalUserDB(user).put(doc);
+  });
+}
+async function getUserClassrooms(user) {
+  return getOrCreateClassroomRegistrationsDoc(user);
+}
+var import_common7, import_moment4, log3, BaseUser, userCoursesDoc, userClassroomsDoc;
+var init_BaseUserDB = __esm({
+  "src/impl/common/BaseUserDB.ts"() {
+    "use strict";
+    init_core();
+    init_util();
+    import_common7 = require("@vue-skuilder/common");
+    import_moment4 = __toESM(require("moment"));
+    init_types_legacy();
+    init_logger();
+    init_userDBHelpers();
+    init_updateQueue();
+    init_user_course_relDB();
+    init_couch();
+    log3 = (s) => {
+      logger.info(s);
+    };
+    BaseUser = class _BaseUser {
+      static _instance;
+      static _initialized = false;
+      static Dummy(syncStrategy) {
+        return new _BaseUser("Me", syncStrategy);
+      }
+      static DOC_IDS = {
+        CONFIG: "CONFIG",
+        COURSE_REGISTRATIONS: "CourseRegistrations",
+        CLASSROOM_REGISTRATIONS: "ClassroomRegistrations"
+      };
+      // private email: string;
+      _username;
+      syncStrategy;
+      getUsername() {
+        return this._username;
       }
-      async getCourseInterface(courseId) {
-        return new UsrCrsData(this, courseId);
+      isLoggedIn() {
+        return !this._username.startsWith(GuestUsername);
       }
-      async getUserEditableCourses() {
-        let courseIDs = [];
-        const registeredCourses = await this.getCourseRegistrationsDoc();
-        courseIDs = courseIDs.concat(
-          registeredCourses.courses.map((course) => {
-            return course.courseID;
-          })
-        );
-        const cfgs = await Promise.all(
-          courseIDs.map(async (id) => {
-            return await getCredentialledCourseConfig(id);
-          })
-        );
-        return cfgs;
+      remote() {
+        return this.remoteDB;
       }
-      async getConfig() {
-        const defaultConfig = {
-          _id: _BaseUser.DOC_IDS.CONFIG,
-          darkMode: false,
-          likesConfetti: false
-        };
-        try {
-          const cfg = await this.localDB.get(_BaseUser.DOC_IDS.CONFIG);
-          logger.debug("Raw config from DB:", cfg);
-          return cfg;
-        } catch (e) {
-          const err = e;
-          if (err.name && err.name === "not_found") {
-            await this.localDB.put(defaultConfig);
-            return this.getConfig();
-          } else {
-            logger.error(`Error setting user default config:`, e);
-            throw new Error(`Error returning the user's configuration: ${JSON.stringify(e)}`);
-          }
+      localDB;
+      remoteDB;
+      writeDB;
+      // Database to use for write operations (local-first approach)
+      updateQueue;
+      async createAccount(username, password) {
+        if (!this.syncStrategy.canCreateAccount()) {
+          throw new Error("Account creation not supported by current sync strategy");
         }
-      }
-      async setConfig(items) {
-        logger.debug(`Setting Config items ${JSON.stringify(items)}`);
-        const c = await this.getConfig();
-        const put = await this.localDB.put({
-          ...c,
-          ...items
-        });
-        if (put.ok) {
-          logger.debug(`Config items set: ${JSON.stringify(items)}`);
-        } else {
-          logger.error(`Error setting config items: ${JSON.stringify(put)}`);
+        if (!this._username.startsWith(GuestUsername)) {
+          throw new Error(
+            `Cannot create a new account while logged in:
+Currently logged-in as ${this._username}.`
+          );
         }
-      }
-      /**
-       *
-       * This function should be called *only* by the pouchdb datalayer provider
-       * auth store.
-       *
-       *
-       * Anyone else seeking the current user should use the auth store's
-       * exported `getCurrentUser` method.
-       *
-       */
-      static async instance(syncStrategy, username) {
-        if (username) {
-          _BaseUser._instance = new _BaseUser(username, syncStrategy);
-          await _BaseUser._instance.init();
-          return _BaseUser._instance;
-        } else if (_BaseUser._instance && _BaseUser._initialized) {
-          return _BaseUser._instance;
-        } else if (_BaseUser._instance) {
-          return new Promise((resolve) => {
-            (function waitForUser() {
-              if (_BaseUser._initialized) {
-                return resolve(_BaseUser._instance);
-              } else {
-                setTimeout(waitForUser, 50);
-              }
-            })();
-          });
-        } else {
-          const guestUsername = await syncStrategy.getCurrentUsername();
-          _BaseUser._instance = new _BaseUser(guestUsername, syncStrategy);
-          await _BaseUser._instance.init();
-          return _BaseUser._instance;
+        const result = await this.syncStrategy.createAccount(username, password);
+        if (result.status === import_common7.Status.ok) {
+          log3(`Account created successfully, updating username to ${username}`);
+          this._username = username;
+          try {
+            localStorage.removeItem("dbUUID");
+          } catch (e) {
+            logger.warn("localStorage not available (Node.js environment):", e);
+          }
+          await this.init();
         }
+        return {
+          status: result.status,
+          error: result.error || ""
+        };
       }
-      constructor(username, syncStrategy) {
-        _BaseUser._initialized = false;
-        this._username = username;
-        this.syncStrategy = syncStrategy;
-        this.setDBandQ();
-      }
-      setDBandQ() {
-        this.localDB = getLocalUserDB(this._username);
-        this.remoteDB = this.syncStrategy.setupRemoteDB(this._username);
-        this.updateQueue = new UpdateQueue(this.localDB);
-      }
-      async init() {
-        _BaseUser._initialized = false;
-        if (this._username === "admin") {
-          _BaseUser._initialized = true;
-          return;
+      async login(username, password) {
+        if (!this.syncStrategy.canAuthenticate()) {
+          throw new Error("Authentication not supported by current sync strategy");
         }
-        this.setDBandQ();
-        this.syncStrategy.startSync(this.localDB, this.remoteDB);
-        void this.applyDesignDocs();
-        void this.deduplicateReviews();
-        _BaseUser._initialized = true;
-      }
-      static designDocs = [
-        {
-          _id: "_design/reviewCards",
-          views: {
-            reviewCards: {
-              map: `function (doc) {
-            if (doc._id && doc._id.indexOf('card_review') === 0 && doc.courseId && doc.cardId) {
-              emit(doc._id, doc.courseId + '-' + doc.cardId);
-            }
-          }`
-            }
+        if (!this._username.startsWith(GuestUsername) && this._username != username) {
+          if (this._username != username) {
+            throw new Error(`Cannot change accounts while logged in.
+        Log out of account ${this.getUsername()} before logging in as ${username}.`);
           }
+          logger.warn(`User ${this._username} is already logged in, but executing login again.`);
         }
-      ];
-      async applyDesignDocs() {
-        if (this._username === "admin") {
-          return;
-        }
-        for (const doc of _BaseUser.designDocs) {
+        const loginResult = await this.syncStrategy.authenticate(username, password);
+        if (loginResult.ok) {
+          log3(`Logged in as ${username}`);
+          this._username = username;
           try {
-            try {
-              const existingDoc = await this.remoteDB.get(doc._id);
-              await this.remoteDB.put({
-                ...doc,
-                _rev: existingDoc._rev
-              });
-            } catch (e) {
-              if (e instanceof Error && e.name === "not_found") {
-                await this.remoteDB.put(doc);
-              } else {
-                throw e;
-              }
-            }
-          } catch (error) {
-            if (error.name && error.name === "conflict") {
-              logger.warn(`Design doc ${doc._id} update conflict - will retry`);
-              await new Promise((resolve) => setTimeout(resolve, 1e3));
-              await this.applyDesignDoc(doc);
-            } else {
-              logger.error(`Failed to apply design doc ${doc._id}:`, error);
-              throw error;
-            }
+            localStorage.removeItem("dbUUID");
+          } catch (e) {
+            logger.warn("localStorage not available (Node.js environment):", e);
+          }
+          await this.init();
+        }
+        return loginResult;
+      }
+      async resetUserData() {
+        if (this.syncStrategy.canAuthenticate()) {
+          return {
+            status: import_common7.Status.error,
+            error: "Reset user data is only available for local-only mode. Use logout instead for remote sync."
+          };
+        }
+        try {
+          const localDB = getLocalUserDB(this._username);
+          const allDocs = await localDB.allDocs({ include_docs: false });
+          const docsToDelete = allDocs.rows.filter((row) => {
+            const id = row.id;
+            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;
+          }).map((row) => ({ _id: row.id, _rev: row.value.rev, _deleted: true }));
+          if (docsToDelete.length > 0) {
+            await localDB.bulkDocs(docsToDelete);
           }
+          await this.init();
+          return { status: import_common7.Status.ok };
+        } catch (error) {
+          logger.error("Failed to reset user data:", error);
+          return {
+            status: import_common7.Status.error,
+            error: error instanceof Error ? error.message : "Unknown error during reset"
+          };
+        }
+      }
+      async logout() {
+        if (!this.syncStrategy.canAuthenticate()) {
+          this._username = await this.syncStrategy.getCurrentUsername();
+          await this.init();
+          return { ok: true };
         }
+        const ret = await this.syncStrategy.logout();
+        this._username = await this.syncStrategy.getCurrentUsername();
+        await this.init();
+        return ret;
       }
-      // Helper method for single doc update with retry
-      async applyDesignDoc(doc, retries = 3) {
+      update(id, update) {
+        return this.updateQueue.update(id, update);
+      }
+      async getCourseRegistrationsDoc() {
+        logger.debug(`Fetching courseRegistrations for ${this.getUsername()}`);
+        let ret;
         try {
-          const existingDoc = await this.remoteDB.get(doc._id);
-          await this.remoteDB.put({
-            ...doc,
-            _rev: existingDoc._rev
-          });
+          const regDoc = await this.localDB.get(
+            _BaseUser.DOC_IDS.COURSE_REGISTRATIONS
+          );
+          return regDoc;
         } catch (e) {
-          if (e instanceof Error && e.name === "conflict" && retries > 0) {
-            await new Promise((resolve) => setTimeout(resolve, 1e3));
-            return this.applyDesignDoc(doc, retries - 1);
+          const err = e;
+          if (err.status === 404) {
+            await this.localDB.put({
+              _id: _BaseUser.DOC_IDS.COURSE_REGISTRATIONS,
+              courses: [],
+              studyWeight: {}
+            });
+            ret = await this.getCourseRegistrationsDoc();
+          } else {
+            throw new Error(
+              `Unexpected error ${JSON.stringify(e)} in getOrCreateCourseRegistrationDoc...`
+            );
           }
-          throw e;
         }
+        return ret;
+      }
+      async getActiveCourses() {
+        const reg = await this.getCourseRegistrationsDoc();
+        return reg.courses.filter((c) => {
+          return c.status === void 0 || c.status === "active";
+        });
       }
       /**
-       * Logs a record of the user's interaction with the card and returns the card's
-       * up-to-date history
-       *
-       * // [ ] #db-refactor extract to a smaller scope - eg, UserStudySession
+       * Returns a promise of the card IDs that the user has
+       * a scheduled review for.
        *
-       * @param record the recent recorded interaction between user and card
-       * @returns The updated state of the card's CardHistory data
        */
-      async putCardRecord(record) {
-        const cardHistoryID = getCardHistoryID(record.courseID, record.cardID);
-        record.timeStamp = import_moment3.default.utc(record.timeStamp).toString();
+      async getActiveCards() {
+        const keys = getStartAndEndKeys2(DocTypePrefixes["SCHEDULED_CARD" /* SCHEDULED_CARD */]);
+        const reviews = await this.remoteDB.allDocs({
+          startkey: keys.startkey,
+          endkey: keys.endkey,
+          include_docs: true
+        });
+        return reviews.rows.map((r) => `${r.doc.courseId}-${r.doc.cardId}`);
+      }
+      async getActivityRecords() {
         try {
-          const cardHistory = await this.update(
-            cardHistoryID,
-            function(h) {
-              h.records.push(record);
-              h.bestInterval = h.bestInterval || 0;
-              h.lapses = h.lapses || 0;
-              h.streak = h.streak || 0;
-              return h;
+          const hist = await this.getHistory();
+          const allRecords = [];
+          if (!Array.isArray(hist)) {
+            logger.error("getHistory did not return an array:", hist);
+            return allRecords;
+          }
+          let sampleCount = 0;
+          for (let i = 0; i < hist.length; i++) {
+            try {
+              if (hist[i] && Array.isArray(hist[i].records)) {
+                hist[i].records.forEach((record) => {
+                  try {
+                    if (!record.timeStamp) {
+                      return;
+                    }
+                    let timeStamp;
+                    if (typeof record.timeStamp === "object") {
+                      if (typeof record.timeStamp.toDate === "function") {
+                        timeStamp = record.timeStamp.toISOString();
+                      } else if (record.timeStamp instanceof Date) {
+                        timeStamp = record.timeStamp.toISOString();
+                      } else {
+                        if (sampleCount < 3) {
+                          logger.warn("Unknown timestamp object type:", record.timeStamp);
+                          sampleCount++;
+                        }
+                        return;
+                      }
+                    } else if (typeof record.timeStamp === "string") {
+                      const date = new Date(record.timeStamp);
+                      if (isNaN(date.getTime())) {
+                        return;
+                      }
+                      timeStamp = record.timeStamp;
+                    } else if (typeof record.timeStamp === "number") {
+                      timeStamp = new Date(record.timeStamp).toISOString();
+                    } else {
+                      return;
+                    }
+                    allRecords.push({
+                      timeStamp,
+                      courseID: record.courseID || "unknown",
+                      cardID: record.cardID || "unknown",
+                      timeSpent: record.timeSpent || 0,
+                      type: "card_view"
+                    });
+                  } catch (err) {
+                  }
+                });
+              }
+            } catch (err) {
+              logger.error("Error processing history item:", err);
             }
-          );
-          cardHistory.records = cardHistory.records.map((record2) => {
-            const ret = {
-              ...record2
-            };
-            ret.timeStamp = import_moment3.default.utc(record2.timeStamp);
-            return ret;
-          });
-          return cardHistory;
-        } catch (e) {
-          const reason = e;
-          if (reason.status === 404) {
-            const initCardHistory = {
-              _id: cardHistoryID,
-              cardID: record.cardID,
-              courseID: record.courseID,
-              records: [record],
-              lapses: 0,
-              streak: 0,
-              bestInterval: 0
-            };
-            void this.remoteDB.put(initCardHistory);
-            return initCardHistory;
-          } else {
-            throw new Error(`putCardRecord failed because of:
-  name:${reason.name}
-  error: ${reason.error}
-  message: ${reason.message}`);
           }
+          logger.debug(`Found ${allRecords.length} activity records`);
+          return allRecords;
+        } catch (err) {
+          logger.error("Error in getActivityRecords:", err);
+          return [];
         }
       }
-      async deduplicateReviews() {
-        try {
-          log3("Starting deduplication of scheduled reviews...");
-          const reviewsMap = {};
-          const duplicateDocIds = [];
-          const scheduledReviews = await this.remoteDB.query("reviewCards/reviewCards");
-          log3(`Found ${scheduledReviews.rows.length} scheduled reviews to process`);
-          scheduledReviews.rows.forEach((r) => {
-            const qualifiedCardId = r.value;
-            const docId = r.key;
-            if (reviewsMap[qualifiedCardId]) {
-              log3(`Found duplicate scheduled review for card: ${qualifiedCardId}`);
-              log3(
-                `Marking earlier review ${reviewsMap[qualifiedCardId]} for deletion, keeping ${docId}`
-              );
-              duplicateDocIds.push(reviewsMap[qualifiedCardId]);
-              reviewsMap[qualifiedCardId] = docId;
-            } else {
-              reviewsMap[qualifiedCardId] = docId;
+      async getReviewstoDate(targetDate, course_id) {
+        const keys = getStartAndEndKeys2(DocTypePrefixes["SCHEDULED_CARD" /* SCHEDULED_CARD */]);
+        const reviews = await this.remoteDB.allDocs({
+          startkey: keys.startkey,
+          endkey: keys.endkey,
+          include_docs: true
+        });
+        log3(
+          `Fetching ${this._username}'s scheduled reviews${course_id ? ` for course ${course_id}` : ""}.`
+        );
+        return reviews.rows.filter((r) => {
+          if (r.id.startsWith(DocTypePrefixes["SCHEDULED_CARD" /* SCHEDULED_CARD */])) {
+            const date = import_moment4.default.utc(
+              r.id.substr(DocTypePrefixes["SCHEDULED_CARD" /* SCHEDULED_CARD */].length),
+              REVIEW_TIME_FORMAT2
+            );
+            if (targetDate.isAfter(date)) {
+              if (course_id === void 0 || r.doc.courseId === course_id) {
+                return true;
+              }
             }
-          });
-          if (duplicateDocIds.length > 0) {
-            log3(`Removing ${duplicateDocIds.length} duplicate reviews...`);
-            const deletePromises = duplicateDocIds.map(async (docId) => {
-              try {
-                const doc = await this.remoteDB.get(docId);
-                await this.remoteDB.remove(doc);
-                log3(`Successfully removed duplicate review: ${docId}`);
-              } catch (error) {
-                log3(`Failed to remove duplicate review ${docId}: ${error}`);
+          }
+        }).map((r) => r.doc);
+      }
+      async getReviewsForcast(daysCount) {
+        const time = import_moment4.default.utc().add(daysCount, "days");
+        return this.getReviewstoDate(time);
+      }
+      async getPendingReviews(course_id) {
+        const now = import_moment4.default.utc();
+        return this.getReviewstoDate(now, course_id);
+      }
+      async getScheduledReviewCount(course_id) {
+        return (await this.getPendingReviews(course_id)).length;
+      }
+      async getRegisteredCourses() {
+        const regDoc = await this.getCourseRegistrationsDoc();
+        return regDoc.courses.filter((c) => {
+          return !c.status || c.status === "active" || c.status === "maintenance-mode";
+        });
+      }
+      async getCourseRegDoc(courseID) {
+        const regDocs = await this.getCourseRegistrationsDoc();
+        const ret = regDocs.courses.find((c) => c.courseID === courseID);
+        if (ret) {
+          return ret;
+        } else {
+          throw new Error(`Course registration not found for course ID: ${courseID}`);
+        }
+      }
+      async registerForCourse(course_id, previewMode = false) {
+        return this.getCourseRegistrationsDoc().then((doc) => {
+          const status = previewMode ? "preview" : "active";
+          logger.debug(`Registering for ${course_id} with status: ${status}`);
+          const regItem = {
+            status,
+            courseID: course_id,
+            user: true,
+            admin: false,
+            moderator: false,
+            elo: {
+              global: {
+                score: 1e3,
+                count: 0
+              },
+              tags: {},
+              misc: {}
+            }
+          };
+          if (doc.courses.filter((course) => {
+            return course.courseID === regItem.courseID;
+          }).length === 0) {
+            log3(`It's a new course registration!`);
+            doc.courses.push(regItem);
+            doc.studyWeight[course_id] = 1;
+          } else {
+            doc.courses.forEach((c) => {
+              log3(`Found the previously registered course!`);
+              if (c.courseID === course_id) {
+                c.status = status;
               }
             });
-            await Promise.all(deletePromises);
-            log3(`Deduplication complete. Processed ${duplicateDocIds.length} duplicates`);
-          } else {
-            log3("No duplicate reviews found");
-          }
-        } catch (error) {
-          log3(`Error during review deduplication: ${error}`);
-        }
-      }
-      /**
-       * Returns a promise of the card IDs that the user has
-       * encountered in the past.
-       *
-       * @param course_id optional specification of individual course
-       */
-      async getSeenCards(course_id) {
-        let prefix = cardHistoryPrefix2;
-        if (course_id) {
-          prefix += course_id;
-        }
-        const docs = await filterAllDocsByPrefix(this.localDB, prefix, {
-          include_docs: false
-        });
-        const ret = [];
-        docs.rows.forEach((row) => {
-          if (row.id.startsWith(cardHistoryPrefix2)) {
-            ret.push(row.id.substr(cardHistoryPrefix2.length));
           }
+          return this.localDB.put(doc);
+        }).catch((e) => {
+          log3(`Registration failed because of: ${JSON.stringify(e)}`);
+          throw e;
         });
-        return ret;
-      }
-      /**
-       *
-       * @returns A promise of the cards that the user has seen in the past.
-       */
-      async getHistory() {
-        const cards = await filterAllDocsByPrefix(
-          this.remoteDB,
-          cardHistoryPrefix2,
-          {
-            include_docs: true,
-            attachments: false
-          }
-        );
-        return cards.rows.map((r) => r.doc);
       }
-      async updateCourseSettings(course_id, settings) {
-        void this.getCourseRegistrationsDoc().then((doc) => {
-          const crs = doc.courses.find((c) => c.courseID === course_id);
-          if (crs) {
-            if (crs.settings === null || crs.settings === void 0) {
-              crs.settings = {};
+      async dropCourse(course_id, dropStatus = "dropped") {
+        return this.getCourseRegistrationsDoc().then((doc) => {
+          let index = -1;
+          for (let i = 0; i < doc.courses.length; i++) {
+            if (doc.courses[i].courseID === course_id) {
+              index = i;
             }
-            settings.forEach((setting) => {
-              crs.settings[setting.key] = setting.value;
-            });
+          }
+          if (index !== -1) {
+            delete doc.studyWeight[course_id];
+            doc.courses[index].status = dropStatus;
+          } else {
+            throw new Error(
+              `User ${this.getUsername()} is not currently registered for course ${course_id}`
+            );
           }
           return this.localDB.put(doc);
         });
       }
-      async getCourseSettings(course_id) {
-        const regDoc = await this.getCourseRegistrationsDoc();
-        const crsDoc = regDoc.courses.find((c) => c.courseID === course_id);
-        if (crsDoc) {
-          return crsDoc.settings;
-        } else {
-          throw new Error(`getCourseSettings Failed:
-      User is not registered for course ${course_id}`);
-        }
+      async getCourseInterface(courseId) {
+        return new UsrCrsData(this, courseId);
       }
-      async getOrCreateClassroomRegistrationsDoc() {
-        let ret;
+      async getUserEditableCourses() {
+        let courseIDs = [];
+        const registeredCourses = await this.getCourseRegistrationsDoc();
+        courseIDs = courseIDs.concat(
+          registeredCourses.courses.map((course) => {
+            return course.courseID;
+          })
+        );
+        const cfgs = await Promise.all(
+          courseIDs.map(async (id) => {
+            return await getCredentialledCourseConfig(id);
+          })
+        );
+        return cfgs;
+      }
+      async getConfig() {
+        const defaultConfig = {
+          _id: _BaseUser.DOC_IDS.CONFIG,
+          darkMode: false,
+          likesConfetti: false,
+          sessionTimeLimit: 5
+        };
         try {
-          ret = await this.remoteDB.get(
-            _BaseUser.DOC_IDS.CLASSROOM_REGISTRATIONS
-          );
+          const cfg = await this.localDB.get(_BaseUser.DOC_IDS.CONFIG);
+          logger.debug("Raw config from DB:", cfg);
+          return cfg;
         } catch (e) {
           const err = e;
-          if (err.status === 404) {
-            await this.remoteDB.put({
-              _id: _BaseUser.DOC_IDS.CLASSROOM_REGISTRATIONS,
-              registrations: []
-            });
-            ret = await this.getOrCreateClassroomRegistrationsDoc();
+          if (err.name && err.name === "not_found") {
+            await this.localDB.put(defaultConfig);
+            return this.getConfig();
           } else {
-            const errorDetails = {
-              name: err.name,
-              status: err.status,
-              message: err.message,
-              reason: err.reason,
-              error: err.error
-            };
-            logger.error(
-              "Database error in getOrCreateClassroomRegistrationsDoc (private method):",
-              errorDetails
-            );
-            throw new Error(
-              `Database error accessing classroom registrations: ${err.message || err.name || "Unknown error"} (status: ${err.status})`
-            );
+            logger.error(`Error setting user default config:`, e);
+            throw new Error(`Error returning the user's configuration: ${JSON.stringify(e)}`);
           }
         }
-        logger.debug(`Returning classroom registrations doc: ${JSON.stringify(ret)}`);
-        return ret;
-      }
-      /**
-       * Retrieves the list of active classroom IDs where the user is registered as a student.
-       *
-       * @returns Promise<string[]> - Array of classroom IDs, or empty array if classroom
-       *                              registration document is unavailable due to database errors
-       *
-       * @description This method gracefully handles database connectivity issues by returning
-       *              an empty array when the classroom registrations document cannot be accessed.
-       *              This ensures that users can still access other application features even
-       *              when classroom functionality is temporarily unavailable.
-       */
-      async getActiveClasses() {
-        try {
-          return (await this.getOrCreateClassroomRegistrationsDoc()).registrations.filter((c) => c.registeredAs === "student").map((c) => c.classID);
-        } catch (error) {
-          logger.warn(
-            "Failed to load classroom registrations, continuing without classroom data:",
-            error
-          );
-          return [];
-        }
-      }
-      async scheduleCardReview(review) {
-        return scheduleCardReviewLocal(this.remoteDB, review);
-      }
-      async removeScheduledCardReview(reviewId) {
-        return removeScheduledCardReviewLocal(this.remoteDB, reviewId);
-      }
-      async registerForClassroom(_classId, _registerAs) {
-        return registerUserForClassroom(this._username, _classId, _registerAs);
-      }
-      async dropFromClassroom(classId) {
-        return dropUserFromClassroom(this._username, classId);
-      }
-      async getUserClassrooms() {
-        return getUserClassrooms(this._username);
-      }
-      async updateUserElo(courseId, elo) {
-        return updateUserElo(this._username, courseId, elo);
-      }
-    };
-    userCoursesDoc = "CourseRegistrations";
-    userClassroomsDoc = "ClassroomRegistrations";
-  }
-});
-
-// src/impl/common/index.ts
-var init_common = __esm({
-  "src/impl/common/index.ts"() {
-    "use strict";
-    init_SyncStrategy();
-    init_BaseUserDB();
-    init_userDBHelpers();
-  }
-});
-
-// src/factory.ts
-function getDataLayer() {
-  if (!dataLayerInstance) {
-    throw new Error("Data layer not initialized. Call initializeDataLayer first.");
-  }
-  return dataLayerInstance;
-}
-var ENV, dataLayerInstance;
-var init_factory = __esm({
-  "src/factory.ts"() {
-    "use strict";
-    init_common();
-    init_logger();
-    ENV = {
-      COUCHDB_SERVER_PROTOCOL: "NOT_SET",
-      COUCHDB_SERVER_URL: "NOT_SET"
-    };
-    dataLayerInstance = null;
-  }
-});
-
-// src/impl/couch/classroomDB.ts
-function getClassroomDB(classID, version) {
-  const dbName = `classdb-${version}-${classID}`;
-  logger.info(`Retrieving classroom db: ${dbName}`);
-  return new pouchdb_setup_default(
-    ENV.COUCHDB_SERVER_PROTOCOL + "://" + ENV.COUCHDB_SERVER_URL + dbName,
-    pouchDBincludeCredentialsConfig
-  );
-}
-async function getClassroomConfig(classID) {
-  return await getClassroomDB(classID, "student").get(CLASSROOM_CONFIG);
-}
-var import_moment4, classroomLookupDBTitle, CLASSROOM_CONFIG, ClassroomDBBase, StudentClassroomDB, TeacherClassroomDB, ClassroomLookupDB;
-var init_classroomDB = __esm({
-  "src/impl/couch/classroomDB.ts"() {
-    "use strict";
-    init_factory();
-    init_logger();
-    import_moment4 = __toESM(require("moment"));
-    init_pouchdb_setup();
-    init_couch();
-    init_courseDB();
-    classroomLookupDBTitle = "classdb-lookup";
-    CLASSROOM_CONFIG = "ClassroomConfig";
-    ClassroomDBBase = class {
-      _id;
-      _db;
-      _cfg;
-      _initComplete = false;
-      _content_prefix = "content";
-      get _content_searchkeys() {
-        return getStartAndEndKeys2(this._content_prefix);
-      }
-      async getAssignedContent() {
-        logger.info(`Getting assigned content...`);
-        const docRows = await this._db.allDocs({
-          startkey: this._content_prefix,
-          endkey: this._content_prefix + `\uFFF0`,
-          include_docs: true
-        });
-        const ret = docRows.rows.map((row) => {
-          return row.doc;
-        });
-        return ret;
       }
-      getContentId(content) {
-        if (content.type === "tag") {
-          return `${this._content_prefix}-${content.courseID}-${content.tagID}`;
+      async setConfig(items) {
+        logger.debug(`Setting Config items ${JSON.stringify(items)}`);
+        const c = await this.getConfig();
+        const put = await this.localDB.put({
+          ...c,
+          ...items
+        });
+        if (put.ok) {
+          logger.debug(`Config items set: ${JSON.stringify(items)}`);
         } else {
-          return `${this._content_prefix}-${content.courseID}`;
+          logger.error(`Error setting config items: ${JSON.stringify(put)}`);
         }
       }
-      get ready() {
-        return this._initComplete;
+      /**
+       *
+       * This function should be called *only* by the pouchdb datalayer provider
+       * auth store.
+       *
+       *
+       * Anyone else seeking the current user should use the auth store's
+       * exported `getCurrentUser` method.
+       *
+       */
+      static async instance(syncStrategy, username) {
+        if (username) {
+          _BaseUser._instance = new _BaseUser(username, syncStrategy);
+          await _BaseUser._instance.init();
+          return _BaseUser._instance;
+        } else if (_BaseUser._instance && _BaseUser._initialized) {
+          return _BaseUser._instance;
+        } else if (_BaseUser._instance) {
+          return new Promise((resolve) => {
+            (function waitForUser() {
+              if (_BaseUser._initialized) {
+                return resolve(_BaseUser._instance);
+              } else {
+                setTimeout(waitForUser, 50);
+              }
+            })();
+          });
+        } else {
+          const guestUsername = await syncStrategy.getCurrentUsername();
+          _BaseUser._instance = new _BaseUser(guestUsername, syncStrategy);
+          await _BaseUser._instance.init();
+          return _BaseUser._instance;
+        }
       }
-      getConfig() {
-        return this._cfg;
+      constructor(username, syncStrategy) {
+        _BaseUser._initialized = false;
+        this._username = username;
+        this.syncStrategy = syncStrategy;
+        this.setDBandQ();
       }
-    };
-    StudentClassroomDB = class _StudentClassroomDB extends ClassroomDBBase {
-      // private readonly _prefix: string = 'content';
-      userMessages;
-      _user;
-      constructor(classID, user) {
-        super();
-        this._id = classID;
-        this._user = user;
+      setDBandQ() {
+        this.localDB = getLocalUserDB(this._username);
+        this.remoteDB = this.syncStrategy.setupRemoteDB(this._username);
+        this.writeDB = this.syncStrategy.getWriteDB ? this.syncStrategy.getWriteDB(this._username) : this.localDB;
+        this.updateQueue = new UpdateQueue(this.localDB, this.writeDB);
       }
       async init() {
-        const dbName = `classdb-student-${this._id}`;
-        this._db = new pouchdb_setup_default(
-          ENV.COUCHDB_SERVER_PROTOCOL + "://" + ENV.COUCHDB_SERVER_URL + dbName,
-          pouchDBincludeCredentialsConfig
-        );
+        _BaseUser._initialized = false;
+        if (this._username === "admin") {
+          _BaseUser._initialized = true;
+          return;
+        }
+        this.setDBandQ();
+        this.syncStrategy.startSync(this.localDB, this.remoteDB);
+        void this.applyDesignDocs();
+        void this.deduplicateReviews();
+        _BaseUser._initialized = true;
+      }
+      static designDocs = [
+        {
+          _id: "_design/reviewCards",
+          views: {
+            reviewCards: {
+              map: `function (doc) {
+            if (doc._id && doc._id.indexOf('card_review') === 0 && doc.courseId && doc.cardId) {
+              emit(doc._id, doc.courseId + '-' + doc.cardId);
+            }
+          }`
+            }
+          }
+        }
+      ];
+      async applyDesignDocs() {
+        if (this._username === "admin") {
+          return;
+        }
+        for (const doc of _BaseUser.designDocs) {
+          try {
+            try {
+              const existingDoc = await this.remoteDB.get(doc._id);
+              await this.remoteDB.put({
+                ...doc,
+                _rev: existingDoc._rev
+              });
+            } catch (e) {
+              if (e instanceof Error && e.name === "not_found") {
+                await this.remoteDB.put(doc);
+              } else {
+                throw e;
+              }
+            }
+          } catch (error) {
+            if (error.name && error.name === "conflict") {
+              logger.warn(`Design doc ${doc._id} update conflict - will retry`);
+              await new Promise((resolve) => setTimeout(resolve, 1e3));
+              await this.applyDesignDoc(doc);
+            } else {
+              logger.error(`Failed to apply design doc ${doc._id}:`, error);
+              throw error;
+            }
+          }
+        }
+      }
+      // Helper method for single doc update with retry
+      async applyDesignDoc(doc, retries = 3) {
         try {
-          const cfg = await this._db.get(CLASSROOM_CONFIG);
-          this._cfg = cfg;
-          this.userMessages = this._db.changes({
-            since: "now",
-            live: true,
-            include_docs: true
+          const existingDoc = await this.remoteDB.get(doc._id);
+          await this.remoteDB.put({
+            ...doc,
+            _rev: existingDoc._rev
           });
-          this._initComplete = true;
-          return;
         } catch (e) {
-          throw new Error(`Error in StudentClassroomDB constructor: ${JSON.stringify(e)}`);
+          if (e instanceof Error && e.name === "conflict" && retries > 0) {
+            await new Promise((resolve) => setTimeout(resolve, 1e3));
+            return this.applyDesignDoc(doc, retries - 1);
+          }
+          throw e;
         }
       }
-      static async factory(classID, user) {
-        const ret = new _StudentClassroomDB(classID, user);
-        await ret.init();
-        return ret;
+      /**
+       * Logs a record of the user's interaction with the card and returns the card's
+       * up-to-date history
+       *
+       * // [ ] #db-refactor extract to a smaller scope - eg, UserStudySession
+       *
+       * @param record the recent recorded interaction between user and card
+       * @returns The updated state of the card's CardHistory data
+       */
+      async putCardRecord(record) {
+        const cardHistoryID = getCardHistoryID(record.courseID, record.cardID);
+        record.timeStamp = import_moment4.default.utc(record.timeStamp).toString();
+        try {
+          const cardHistory = await this.update(
+            cardHistoryID,
+            function(h) {
+              h.records.push(record);
+              h.bestInterval = h.bestInterval || 0;
+              h.lapses = h.lapses || 0;
+              h.streak = h.streak || 0;
+              return h;
+            }
+          );
+          cardHistory.records = cardHistory.records.map((record2) => {
+            const ret = {
+              ...record2
+            };
+            ret.timeStamp = import_moment4.default.utc(record2.timeStamp);
+            return ret;
+          });
+          return cardHistory;
+        } catch (e) {
+          const reason = e;
+          if (reason.status === 404) {
+            const initCardHistory = {
+              _id: cardHistoryID,
+              cardID: record.cardID,
+              courseID: record.courseID,
+              records: [record],
+              lapses: 0,
+              streak: 0,
+              bestInterval: 0
+            };
+            const putResult = await this.writeDB.put(initCardHistory);
+            return { ...initCardHistory, _rev: putResult.rev };
+          } else {
+            throw new Error(`putCardRecord failed because of:
+  name:${reason.name}
+  error: ${reason.error}
+  message: ${reason.message}`);
+          }
+        }
       }
-      setChangeFcn(f) {
-        void this.userMessages.on("change", f);
+      async deduplicateReviews() {
+        try {
+          log3("Starting deduplication of scheduled reviews...");
+          const reviewsMap = {};
+          const duplicateDocIds = [];
+          const scheduledReviews = await this.remoteDB.query("reviewCards/reviewCards");
+          log3(`Found ${scheduledReviews.rows.length} scheduled reviews to process`);
+          scheduledReviews.rows.forEach((r) => {
+            const qualifiedCardId = r.value;
+            const docId = r.key;
+            if (reviewsMap[qualifiedCardId]) {
+              log3(`Found duplicate scheduled review for card: ${qualifiedCardId}`);
+              log3(
+                `Marking earlier review ${reviewsMap[qualifiedCardId]} for deletion, keeping ${docId}`
+              );
+              duplicateDocIds.push(reviewsMap[qualifiedCardId]);
+              reviewsMap[qualifiedCardId] = docId;
+            } else {
+              reviewsMap[qualifiedCardId] = docId;
+            }
+          });
+          if (duplicateDocIds.length > 0) {
+            log3(`Removing ${duplicateDocIds.length} duplicate reviews...`);
+            const deletePromises = duplicateDocIds.map(async (docId) => {
+              try {
+                const doc = await this.remoteDB.get(docId);
+                await this.writeDB.remove(doc);
+                log3(`Successfully removed duplicate review: ${docId}`);
+              } catch (error) {
+                log3(`Failed to remove duplicate review ${docId}: ${error}`);
+              }
+            });
+            await Promise.all(deletePromises);
+            log3(`Deduplication complete. Processed ${duplicateDocIds.length} duplicates`);
+          } else {
+            log3("No duplicate reviews found");
+          }
+        } catch (error) {
+          log3(`Error during review deduplication: ${error}`);
+        }
       }
-      async getPendingReviews() {
-        const u = this._user;
-        return (await u.getPendingReviews()).filter((r) => r.scheduledFor === "classroom" && r.schedulingAgentId === this._id).map((r) => {
-          return {
-            ...r,
-            qualifiedID: `${r.courseId}-${r.cardId}`,
-            courseID: r.courseId,
-            cardID: r.cardId,
-            contentSourceType: "classroom",
-            contentSourceID: this._id,
-            reviewID: r._id,
-            status: "review"
-          };
+      /**
+       * Returns a promise of the card IDs that the user has
+       * encountered in the past.
+       *
+       * @param course_id optional specification of individual course
+       */
+      async getSeenCards(course_id) {
+        let prefix = DocTypePrefixes["CARDRECORD" /* CARDRECORD */];
+        if (course_id) {
+          prefix += course_id;
+        }
+        const docs = await filterAllDocsByPrefix2(this.localDB, prefix, {
+          include_docs: false
+        });
+        const ret = [];
+        docs.rows.forEach((row) => {
+          if (row.id.startsWith(DocTypePrefixes["CARDRECORD" /* CARDRECORD */])) {
+            ret.push(row.id.substr(DocTypePrefixes["CARDRECORD" /* CARDRECORD */].length));
+          }
         });
+        return ret;
       }
-      async getNewCards() {
-        const activeCards = await this._user.getActiveCards();
-        const now = import_moment4.default.utc();
-        const assigned = await this.getAssignedContent();
-        const due = assigned.filter((c) => now.isAfter(import_moment4.default.utc(c.activeOn, REVIEW_TIME_FORMAT2)));
-        logger.info(`Due content: ${JSON.stringify(due)}`);
-        let ret = [];
-        for (let i = 0; i < due.length; i++) {
-          const content = due[i];
-          if (content.type === "course") {
-            const db = new CourseDB(content.courseID, async () => this._user);
-            ret = ret.concat(await db.getNewCards());
-          } else if (content.type === "tag") {
-            const tagDoc = await getTag(content.courseID, content.tagID);
-            ret = ret.concat(
-              tagDoc.taggedCards.map((c) => {
-                return {
-                  courseID: content.courseID,
-                  cardID: c,
-                  qualifiedID: `${content.courseID}-${c}`,
-                  contentSourceType: "classroom",
-                  contentSourceID: this._id,
-                  status: "new"
-                };
-              })
-            );
-          } else if (content.type === "card") {
-            ret.push(await getCourseDB2(content.courseID).get(content.cardID));
+      /**
+       *
+       * @returns A promise of the cards that the user has seen in the past.
+       */
+      async getHistory() {
+        const cards = await filterAllDocsByPrefix2(
+          this.remoteDB,
+          DocTypePrefixes["CARDRECORD" /* CARDRECORD */],
+          {
+            include_docs: true,
+            attachments: false
           }
-        }
-        logger.info(`New Cards from classroom ${this._cfg.name}: ${ret.map((c) => c.qualifiedID)}`);
-        return ret.filter((c) => {
-          if (activeCards.some((ac) => c.qualifiedID.includes(ac))) {
-            return false;
-          } else {
-            return true;
+        );
+        return cards.rows.map((r) => r.doc);
+      }
+      async updateCourseSettings(course_id, settings) {
+        void this.getCourseRegistrationsDoc().then((doc) => {
+          const crs = doc.courses.find((c) => c.courseID === course_id);
+          if (crs) {
+            if (crs.settings === null || crs.settings === void 0) {
+              crs.settings = {};
+            }
+            settings.forEach((setting) => {
+              crs.settings[setting.key] = setting.value;
+            });
           }
+          return this.localDB.put(doc);
         });
       }
-    };
-    TeacherClassroomDB = class _TeacherClassroomDB extends ClassroomDBBase {
-      _stuDb;
-      constructor(classID) {
-        super();
-        this._id = classID;
+      async getCourseSettings(course_id) {
+        const regDoc = await this.getCourseRegistrationsDoc();
+        const crsDoc = regDoc.courses.find((c) => c.courseID === course_id);
+        if (crsDoc) {
+          return crsDoc.settings;
+        } else {
+          throw new Error(`getCourseSettings Failed:
+      User is not registered for course ${course_id}`);
+        }
       }
-      async init() {
-        const dbName = `classdb-teacher-${this._id}`;
-        const stuDbName = `classdb-student-${this._id}`;
-        this._db = new pouchdb_setup_default(
-          ENV.COUCHDB_SERVER_PROTOCOL + "://" + ENV.COUCHDB_SERVER_URL + dbName,
-          pouchDBincludeCredentialsConfig
-        );
-        this._stuDb = new pouchdb_setup_default(
-          ENV.COUCHDB_SERVER_PROTOCOL + "://" + ENV.COUCHDB_SERVER_URL + stuDbName,
-          pouchDBincludeCredentialsConfig
-        );
+      async getOrCreateClassroomRegistrationsDoc() {
+        let ret;
         try {
-          return this._db.get(CLASSROOM_CONFIG).then((cfg) => {
-            this._cfg = cfg;
-            this._initComplete = true;
-          }).then(() => {
-            return;
-          });
+          ret = await this.remoteDB.get(
+            _BaseUser.DOC_IDS.CLASSROOM_REGISTRATIONS
+          );
         } catch (e) {
-          throw new Error(`Error in TeacherClassroomDB constructor: ${JSON.stringify(e)}`);
+          const err = e;
+          if (err.status === 404) {
+            await this.writeDB.put({
+              _id: _BaseUser.DOC_IDS.CLASSROOM_REGISTRATIONS,
+              registrations: []
+            });
+            ret = await this.getOrCreateClassroomRegistrationsDoc();
+          } else {
+            const errorDetails = {
+              name: err.name,
+              status: err.status,
+              message: err.message,
+              reason: err.reason,
+              error: err.error
+            };
+            logger.error(
+              "Database error in getOrCreateClassroomRegistrationsDoc (private method):",
+              errorDetails
+            );
+            throw new Error(
+              `Database error accessing classroom registrations: ${err.message || err.name || "Unknown error"} (status: ${err.status})`
+            );
+          }
         }
-      }
-      static async factory(classID) {
-        const ret = new _TeacherClassroomDB(classID);
-        await ret.init();
+        logger.debug(`Returning classroom registrations doc: ${JSON.stringify(ret)}`);
         return ret;
       }
-      async removeContent(content) {
-        const contentID = this.getContentId(content);
+      /**
+       * Retrieves the list of active classroom IDs where the user is registered as a student.
+       *
+       * @returns Promise<string[]> - Array of classroom IDs, or empty array if classroom
+       *                              registration document is unavailable due to database errors
+       *
+       * @description This method gracefully handles database connectivity issues by returning
+       *              an empty array when the classroom registrations document cannot be accessed.
+       *              This ensures that users can still access other application features even
+       *              when classroom functionality is temporarily unavailable.
+       */
+      async getActiveClasses() {
         try {
-          const doc = await this._db.get(contentID);
-          await this._db.remove(doc);
-          void this._db.replicate.to(this._stuDb, {
-            doc_ids: [contentID]
-          });
+          return (await this.getOrCreateClassroomRegistrationsDoc()).registrations.filter((c) => c.registeredAs === "student").map((c) => c.classID);
         } catch (error) {
-          logger.error("Failed to remove content:", contentID, error);
+          logger.warn(
+            "Failed to load classroom registrations, continuing without classroom data:",
+            error
+          );
+          return [];
         }
       }
-      async assignContent(content) {
-        let put;
-        const id = this.getContentId(content);
-        if (content.type === "tag") {
-          put = await this._db.put({
-            courseID: content.courseID,
-            tagID: content.tagID,
-            type: "tag",
-            _id: id,
-            assignedBy: content.assignedBy,
-            assignedOn: import_moment4.default.utc(),
-            activeOn: content.activeOn || import_moment4.default.utc()
-          });
-        } else {
-          put = await this._db.put({
-            courseID: content.courseID,
-            type: "course",
-            _id: id,
-            assignedBy: content.assignedBy,
-            assignedOn: import_moment4.default.utc(),
-            activeOn: content.activeOn || import_moment4.default.utc()
-          });
-        }
-        if (put.ok) {
-          void this._db.replicate.to(this._stuDb, {
-            doc_ids: [id]
-          });
-          return true;
-        } else {
-          return false;
-        }
+      async scheduleCardReview(review) {
+        return scheduleCardReviewLocal(this.writeDB, review);
+      }
+      async removeScheduledCardReview(reviewId) {
+        return removeScheduledCardReviewLocal(this.writeDB, reviewId);
+      }
+      async registerForClassroom(_classId, _registerAs) {
+        return registerUserForClassroom(this._username, _classId, _registerAs);
+      }
+      async dropFromClassroom(classId) {
+        return dropUserFromClassroom(this._username, classId);
+      }
+      async getUserClassrooms() {
+        return getUserClassrooms(this._username);
+      }
+      async updateUserElo(courseId, elo) {
+        return updateUserElo(this._username, courseId, elo);
       }
     };
-    ClassroomLookupDB = () => new pouchdb_setup_default(ENV.COUCHDB_SERVER_PROTOCOL + "://" + ENV.COUCHDB_SERVER_URL + classroomLookupDBTitle, {
-      skip_setup: true
-    });
+    userCoursesDoc = "CourseRegistrations";
+    userClassroomsDoc = "ClassroomRegistrations";
   }
 });
 
-// src/core/interfaces/contentSource.ts
-function isReview(item) {
-  const ret = item.status === "review" || item.status === "failed-review" || "reviewID" in item;
-  return ret;
-}
-async function getStudySource(source, user) {
-  if (source.type === "classroom") {
-    return await StudentClassroomDB.factory(source.id, user);
-  } else {
-    return getDataLayer().getCourseDB(source.id);
+// src/impl/common/index.ts
+var init_common = __esm({
+  "src/impl/common/index.ts"() {
+    "use strict";
+    init_SyncStrategy();
+    init_BaseUserDB();
+    init_userDBHelpers();
+  }
+});
+
+// src/factory.ts
+function getDataLayer() {
+  if (!dataLayerInstance) {
+    throw new Error("Data layer not initialized. Call initializeDataLayer first.");
   }
+  return dataLayerInstance;
 }
-var init_contentSource = __esm({
-  "src/core/interfaces/contentSource.ts"() {
+var ENV, dataLayerInstance;
+var init_factory = __esm({
+  "src/factory.ts"() {
     "use strict";
-    init_factory();
-    init_classroomDB();
+    init_common();
+    init_logger();
+    ENV = {
+      COUCHDB_SERVER_PROTOCOL: "NOT_SET",
+      COUCHDB_SERVER_URL: "NOT_SET"
+    };
+    dataLayerInstance = null;
   }
 });
 
 // src/impl/couch/adminDB.ts
 var AdminDB;
-var init_adminDB = __esm({
+var init_adminDB2 = __esm({
   "src/impl/couch/adminDB.ts"() {
     "use strict";
     init_pouchdb_setup();
     init_factory();
     init_couch();
-    init_classroomDB();
+    init_classroomDB2();
     init_courseLookupDB();
     init_logger();
     AdminDB = class {
@@ -2607,7 +2716,7 @@ var init_adminDB = __esm({
       async getUsers() {
         return (await this.usersDB.allDocs({
           include_docs: true,
-          ...getStartAndEndKeys2("org.couchdb.user:")
+          ...getStartAndEndKeys("org.couchdb.user:")
         })).rows.map((r) => r.doc);
       }
       async getCourses() {
@@ -2700,14 +2809,14 @@ var init_auth = __esm({
 });
 
 // src/impl/couch/CouchDBSyncStrategy.ts
-var import_common8, log4, CouchDBSyncStrategy;
+var import_common9, log4, CouchDBSyncStrategy;
 var init_CouchDBSyncStrategy = __esm({
   "src/impl/couch/CouchDBSyncStrategy.ts"() {
     "use strict";
     init_factory();
     init_types_legacy();
     init_logger();
-    import_common8 = require("@vue-skuilder/common");
+    import_common9 = require("@vue-skuilder/common");
     init_common();
     init_pouchdb_setup();
     init_couch();
@@ -2725,6 +2834,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, {
@@ -2759,32 +2875,32 @@ var init_CouchDBSyncStrategy = __esm({
             log4(`CREATEACCOUNT: logged in as new user: ${loginResult.ok}`);
             if (loginResult.ok) {
               return {
-                status: import_common8.Status.ok,
+                status: import_common9.Status.ok,
                 error: void 0
               };
             } else {
               return {
-                status: import_common8.Status.error,
+                status: import_common9.Status.error,
                 error: "Failed to log in after account creation"
               };
             }
           } else {
             logger.warn(`Signup not OK: ${JSON.stringify(signupRequest)}`);
             return {
-              status: import_common8.Status.error,
+              status: import_common9.Status.error,
               error: "Account creation failed"
             };
           }
         } catch (e) {
           if (e.reason === "Document update conflict.") {
             return {
-              status: import_common8.Status.error,
+              status: import_common9.Status.error,
               error: "This username is taken!"
             };
           }
           logger.error(`Error on signup: ${JSON.stringify(e)}`);
           return {
-            status: import_common8.Status.error,
+            status: import_common9.Status.error,
             error: e.message || "Unknown error during account creation"
           };
         }
@@ -2878,15 +2994,14 @@ __export(couch_exports, {
   CouchDBSyncStrategy: () => CouchDBSyncStrategy,
   CourseDB: () => CourseDB,
   CoursesDB: () => CoursesDB,
-  REVIEW_PREFIX: () => REVIEW_PREFIX2,
-  REVIEW_TIME_FORMAT: () => REVIEW_TIME_FORMAT2,
+  REVIEW_TIME_FORMAT: () => REVIEW_TIME_FORMAT,
   StudentClassroomDB: () => StudentClassroomDB,
   TeacherClassroomDB: () => TeacherClassroomDB,
   addNote55: () => addNote55,
   addTagToCard: () => addTagToCard,
   createTag: () => createTag,
   deleteTag: () => deleteTag,
-  filterAllDocsByPrefix: () => filterAllDocsByPrefix2,
+  filterAllDocsByPrefix: () => filterAllDocsByPrefix,
   getAncestorTagIDs: () => getAncestorTagIDs,
   getAppliedTags: () => getAppliedTags,
   getChildTagStubs: () => getChildTagStubs,
@@ -2903,7 +3018,7 @@ __export(couch_exports, {
   getCredentialledDataShapes: () => getCredentialledDataShapes,
   getLatestVersion: () => getLatestVersion,
   getRandomCards: () => getRandomCards,
-  getStartAndEndKeys: () => getStartAndEndKeys2,
+  getStartAndEndKeys: () => getStartAndEndKeys,
   getStudySource: () => getStudySource,
   getTag: () => getTag,
   getTagID: () => getTagID,
@@ -3031,16 +3146,16 @@ function scheduleCardReview(review) {
   const now = import_moment5.default.utc();
   logger.info(`Scheduling for review in: ${review.time.diff(now, "h") / 24} days`);
   void getCouchUserDB(review.user).put({
-    _id: REVIEW_PREFIX2 + review.time.format(REVIEW_TIME_FORMAT2),
+    _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
   });
 }
-function filterAllDocsByPrefix2(db, prefix, opts) {
+function filterAllDocsByPrefix(db, prefix, opts) {
   const options = {
     startkey: prefix,
     endkey: prefix + "\uFFF0",
@@ -3051,13 +3166,13 @@ function filterAllDocsByPrefix2(db, prefix, opts) {
   }
   return db.allDocs(options);
 }
-function getStartAndEndKeys2(key) {
+function getStartAndEndKeys(key) {
   return {
     startkey: key,
     endkey: key + "\uFFF0"
   };
 }
-var import_moment5, import_process, isBrowser, expiryDocID, GUEST_LOCAL_DB, localUserDB, pouchDBincludeCredentialsConfig, REVIEW_PREFIX2, REVIEW_TIME_FORMAT2;
+var import_moment5, import_process, isBrowser, expiryDocID, GUEST_LOCAL_DB, localUserDB, pouchDBincludeCredentialsConfig, REVIEW_TIME_FORMAT;
 var init_couch = __esm({
   "src/impl/couch/index.ts"() {
     init_factory();
@@ -3067,8 +3182,8 @@ var init_couch = __esm({
     init_pouchdb_setup();
     import_process = __toESM(require("process"));
     init_contentSource();
-    init_adminDB();
-    init_classroomDB();
+    init_adminDB2();
+    init_classroomDB2();
     init_courseAPI();
     init_courseDB();
     init_CouchDBSyncStrategy();
@@ -3085,8 +3200,7 @@ 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";
+    REVIEW_TIME_FORMAT = "YYYY-MM-DD--kk:mm:ss-SSS";
   }
 });
 init_couch();
@@ -3098,7 +3212,6 @@ init_couch();
   CouchDBSyncStrategy,
   CourseDB,
   CoursesDB,
-  REVIEW_PREFIX,
   REVIEW_TIME_FORMAT,
   StudentClassroomDB,
   TeacherClassroomDB,