@vue-skuilder/db 0.1.4 → 0.1.6

package/dist/impl/couch/index.js

@@ -0,0 +1,3075 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __glob = (map) => (path) => {
+  var fn = map[path];
+  if (fn) return fn();
+  throw new Error("Module not found in bundle: " + path);
+};
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/util/logger.ts
+var isDevelopment, logger;
+var init_logger = __esm({
+  "src/util/logger.ts"() {
+    "use strict";
+    isDevelopment = typeof process !== "undefined" && process.env.NODE_ENV === "development";
+    logger = {
+      /**
+       * Debug-level logging - only shown in development
+       */
+      debug: (message, ...args) => {
+        if (isDevelopment) {
+          console.debug(`[DB:DEBUG] ${message}`, ...args);
+        }
+      },
+      /**
+       * Info-level logging - general information
+       */
+      info: (message, ...args) => {
+        console.info(`[DB:INFO] ${message}`, ...args);
+      },
+      /**
+       * Warning-level logging - potential issues
+       */
+      warn: (message, ...args) => {
+        console.warn(`[DB:WARN] ${message}`, ...args);
+      },
+      /**
+       * Error-level logging - serious problems
+       */
+      error: (message, ...args) => {
+        console.error(`[DB:ERROR] ${message}`, ...args);
+      },
+      /**
+       * Log function for backward compatibility with existing log() usage
+       */
+      log: (message, ...args) => {
+        if (isDevelopment) {
+          console.log(`[DB:LOG] ${message}`, ...args);
+        }
+      }
+    };
+  }
+});
+
+// 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_logger();
+    ENV = {
+      COUCHDB_SERVER_PROTOCOL: "NOT_SET",
+      COUCHDB_SERVER_URL: "NOT_SET"
+    };
+    dataLayerInstance = null;
+  }
+});
+
+// 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/impl/couch/pouchdb-setup.ts
+var import_pouchdb, import_pouchdb_find, import_pouchdb_authentication, pouchdb_setup_default;
+var init_pouchdb_setup = __esm({
+  "src/impl/couch/pouchdb-setup.ts"() {
+    "use strict";
+    import_pouchdb = __toESM(require("pouchdb"));
+    import_pouchdb_find = __toESM(require("pouchdb-find"));
+    import_pouchdb_authentication = __toESM(require("@nilock2/pouchdb-authentication"));
+    import_pouchdb.default.plugin(import_pouchdb_find.default);
+    import_pouchdb.default.plugin(import_pouchdb_authentication.default);
+    import_pouchdb.default.defaults({
+      ajax: {
+        timeout: 6e4
+      }
+    });
+    pouchdb_setup_default = import_pouchdb.default;
+  }
+});
+
+// src/util/Loggable.ts
+var Loggable;
+var init_Loggable = __esm({
+  "src/util/Loggable.ts"() {
+    "use strict";
+    Loggable = class {
+      log(...args) {
+        console.log(`LOG-${this._className}@${/* @__PURE__ */ new Date()}:`, ...args);
+      }
+      error(...args) {
+        console.error(`ERROR-${this._className}@${/* @__PURE__ */ new Date()}:`, ...args);
+      }
+    };
+  }
+});
+
+// src/impl/couch/updateQueue.ts
+var UpdateQueue;
+var init_updateQueue = __esm({
+  "src/impl/couch/updateQueue.ts"() {
+    "use strict";
+    init_Loggable();
+    init_logger();
+    UpdateQueue = class extends Loggable {
+      _className = "UpdateQueue";
+      pendingUpdates = {};
+      inprogressUpdates = {};
+      db;
+      update(id, update) {
+        logger.debug(`Update requested on doc: ${id}`);
+        if (this.pendingUpdates[id]) {
+          this.pendingUpdates[id].push(update);
+        } else {
+          this.pendingUpdates[id] = [update];
+        }
+        return this.applyUpdates(id);
+      }
+      constructor(db) {
+        super();
+        this.db = db;
+        logger.debug(`UpdateQ initialized...`);
+        void this.db.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();
+          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);
+              logger.debug(`Retrieved doc: ${id}`);
+              while (this.pendingUpdates[id].length !== 0) {
+                const update = this.pendingUpdates[id].splice(0, 1)[0];
+                if (typeof update === "function") {
+                  doc = { ...doc, ...update(doc) };
+                } else {
+                  doc = {
+                    ...doc,
+                    ...update
+                  };
+                }
+              }
+              await this.db.put(doc);
+              logger.debug(`Put doc: ${id}`);
+              if (this.pendingUpdates[id].length === 0) {
+                this.inprogressUpdates[id] = false;
+                delete this.inprogressUpdates[id];
+              } else {
+                return this.applyUpdates(id);
+              }
+              return doc;
+            } catch (e) {
+              delete this.inprogressUpdates[id];
+              if (this.pendingUpdates[id]) {
+                delete this.pendingUpdates[id];
+              }
+              logger.error(`Error on attemped update: ${JSON.stringify(e)}`);
+              throw e;
+            }
+          } else {
+            throw new Error(`Empty Updates Queue Triggered`);
+          }
+        }
+      }
+    };
+  }
+});
+
+// src/impl/couch/clientCache.ts
+async function GET_CACHED(k, f) {
+  if (CLIENT_CACHE[k]) {
+    return CLIENT_CACHE[k];
+  }
+  CLIENT_CACHE[k] = f ? await f(k) : await GET_ITEM(k);
+  return GET_CACHED(k);
+}
+async function GET_ITEM(k) {
+  throw new Error(`No implementation found for GET_CACHED(${k})`);
+}
+var CLIENT_CACHE;
+var init_clientCache = __esm({
+  "src/impl/couch/clientCache.ts"() {
+    "use strict";
+    CLIENT_CACHE = {};
+  }
+});
+
+// src/impl/common/SyncStrategy.ts
+var init_SyncStrategy = __esm({
+  "src/impl/common/SyncStrategy.ts"() {
+    "use strict";
+  }
+});
+
+// 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/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) {
+  return new pouchdb_setup_default(`userdb-${username}`, {});
+}
+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();
+    REVIEW_PREFIX = "card_review_";
+    REVIEW_TIME_FORMAT = "YYYY-MM-DD--kk:mm:ss-SSS";
+    log2 = (s) => {
+      logger.info(s);
+    };
+  }
+});
+
+// src/impl/couch/user-course-relDB.ts
+var import_moment2, UsrCrsData;
+var init_user_course_relDB = __esm({
+  "src/impl/couch/user-course-relDB.ts"() {
+    "use strict";
+    import_moment2 = __toESM(require("moment"));
+    init_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);
+      }
+      async getScheduledReviewCount() {
+        return (await this.getPendingReviews()).length;
+      }
+      async getCourseSettings() {
+        const regDoc = await this.user.getCourseRegistrationsDoc();
+        const crsDoc = regDoc.courses.find((c) => c.courseID === this._courseId);
+        if (crsDoc && crsDoc.settings) {
+          return crsDoc.settings;
+        } else {
+          logger.warn(`no settings found during lookup on course ${this._courseId}`);
+          return {};
+        }
+      }
+      updateCourseSettings(updates) {
+        void this.user.updateCourseSettings(this._courseId, updates);
+      }
+      async getReviewstoDate(targetDate) {
+        const keys = getStartAndEndKeys2(REVIEW_PREFIX2);
+        const reviews = await this.user.remote().allDocs({
+          startkey: keys.startkey,
+          endkey: keys.endkey,
+          include_docs: true
+        });
+        logger.debug(
+          `Fetching ${this.user.getUsername()}'s scheduled reviews for course ${this._courseId}.`
+        );
+        return reviews.rows.filter((r) => {
+          if (r.id.startsWith(REVIEW_PREFIX2)) {
+            const date = import_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);
+      }
+    };
+  }
+});
+
+// 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_common, import_moment3, log3, cardHistoryPrefix2, BaseUser, userCoursesDoc, userClassroomsDoc;
+var init_BaseUserDB = __esm({
+  "src/impl/common/BaseUserDB.ts"() {
+    "use strict";
+    init_util();
+    import_common = 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);
+      }
+      static DOC_IDS = {
+        CONFIG: "CONFIG",
+        COURSE_REGISTRATIONS: "CourseRegistrations",
+        CLASSROOM_REGISTRATIONS: "ClassroomRegistrations"
+      };
+      // private email: string;
+      _username;
+      syncStrategy;
+      getUsername() {
+        return this._username;
+      }
+      isLoggedIn() {
+        return !this._username.startsWith(GuestUsername);
+      }
+      remoteDB;
+      remote() {
+        return this.remoteDB;
+      }
+      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_common.Status.ok) {
+          log3(`Account created successfully, updating username to ${username}`);
+          this._username = username;
+          localStorage.removeItem("dbUUID");
+          await this.init();
+        }
+        return {
+          status: result.status,
+          error: result.error || ""
+        };
+      }
+      async login(username, password) {
+        if (!this.syncStrategy.canAuthenticate()) {
+          throw new Error("Authentication not supported by current sync strategy");
+        }
+        if (!this._username.startsWith(GuestUsername)) {
+          throw new Error(`Cannot change accounts while logged in.
+      Log out of account ${this.getUsername()} before logging in as ${username}.`);
+        }
+        const loginResult = await this.syncStrategy.authenticate(username, password);
+        if (loginResult.ok) {
+          log3(`Logged in as ${username}`);
+          this._username = username;
+          localStorage.removeItem("dbUUID");
+          await this.init();
+        }
+        return loginResult;
+      }
+      async resetUserData() {
+        if (this.syncStrategy.canAuthenticate()) {
+          return {
+            status: import_common.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_common.Status.ok };
+        } catch (error) {
+          logger.error("Failed to reset user data:", error);
+          return {
+            status: import_common.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);
+      }
+      async getCourseRegistrationsDoc() {
+        logger.debug(`Fetching courseRegistrations for ${this.getUsername()}`);
+        let ret;
+        try {
+          const regDoc = await this.localDB.get(
+            _BaseUser.DOC_IDS.COURSE_REGISTRATIONS
+          );
+          return regDoc;
+        } 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...`
+            );
+          }
+        }
+        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}`);
+      }
+      async getActivityRecords() {
+        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 [];
+        }
+      }
+      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 getReviewsForcast(daysCount) {
+        const time = import_moment3.default.utc().add(daysCount, "days");
+        return this.getReviewstoDate(time);
+      }
+      async getPendingReviews(course_id) {
+        const now = import_moment3.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;
+              }
+            });
+          }
+          return this.localDB.put(doc);
+        }).catch((e) => {
+          log3(`Registration failed because of: ${JSON.stringify(e)}`);
+          throw e;
+        });
+      }
+      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);
+        });
+      }
+      async getCourseInterface(courseId) {
+        return new UsrCrsData(this, courseId);
+      }
+      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
+        };
+        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)}`);
+          }
+        }
+      }
+      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)}`);
+        }
+      }
+      /**
+       *
+       * 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;
+        }
+      }
+      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;
+        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() {
+        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 instanceof Error && 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 existingDoc = await this.remoteDB.get(doc._id);
+          await this.remoteDB.put({
+            ...doc,
+            _rev: existingDoc._rev
+          });
+        } catch (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;
+        }
+      }
+      /**
+       * 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_moment3.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_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}`);
+          }
+        }
+      }
+      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.remoteDB.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}`);
+        }
+      }
+      /**
+       * 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 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 = {};
+            }
+            settings.forEach((setting) => {
+              crs.settings[setting.key] = setting.value;
+            });
+          }
+          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 getOrCreateClassroomRegistrationsDoc() {
+        let ret;
+        try {
+          ret = await this.remoteDB.get(
+            _BaseUser.DOC_IDS.CLASSROOM_REGISTRATIONS
+          );
+        } catch (e) {
+          const err = e;
+          if (err.status === 404) {
+            await this.remoteDB.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})`
+            );
+          }
+        }
+        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/impl/couch/courseAPI.ts
+async function addNote55(courseID, codeCourse, shape, data, author, tags, uploads, elo = (0, import_common3.blankCourseElo)()) {
+  const db = getCourseDB(courseID);
+  const payload = (0, import_common4.prepareNote55)(courseID, codeCourse, shape, data, author, tags, uploads);
+  const result = await db.post(payload);
+  const dataShapeId = import_common2.NameSpacer.getDataShapeString({
+    course: codeCourse,
+    dataShape: shape.name
+  });
+  if (result.ok) {
+    try {
+      await createCards(courseID, dataShapeId, result.id, tags, elo, author);
+    } catch (error) {
+      let errorMessage = "Unknown error";
+      if (error instanceof Error) {
+        errorMessage = error.message;
+      } else if (error && typeof error === "object" && "reason" in error) {
+        errorMessage = error.reason;
+      } else if (error && typeof error === "object" && "message" in error) {
+        errorMessage = error.message;
+      } else {
+        errorMessage = String(error);
+      }
+      logger.error(`[addNote55] Failed to create cards for note ${result.id}: ${errorMessage}`);
+      result.cardCreationFailed = true;
+      result.cardCreationError = errorMessage;
+    }
+  } else {
+    logger.error(`[addNote55] Error adding note. Result: ${JSON.stringify(result)}`);
+  }
+  return result;
+}
+async function createCards(courseID, datashapeID, noteID, tags, elo = (0, import_common3.blankCourseElo)(), author) {
+  const cfg = await getCredentialledCourseConfig(courseID);
+  const dsDescriptor = import_common2.NameSpacer.getDataShapeDescriptor(datashapeID);
+  let questionViewTypes = [];
+  for (const ds of cfg.dataShapes) {
+    if (ds.name === datashapeID) {
+      questionViewTypes = ds.questionTypes;
+    }
+  }
+  if (questionViewTypes.length === 0) {
+    const errorMsg = `No questionViewTypes found for datashapeID: ${datashapeID} in course config. Cards cannot be created.`;
+    logger.error(errorMsg);
+    throw new Error(errorMsg);
+  }
+  for (const questionView of questionViewTypes) {
+    await createCard(questionView, courseID, dsDescriptor, noteID, tags, elo, author);
+  }
+}
+async function createCard(questionViewName, courseID, dsDescriptor, noteID, tags, elo = (0, import_common3.blankCourseElo)(), author) {
+  const qDescriptor = import_common2.NameSpacer.getQuestionDescriptor(questionViewName);
+  const cfg = await getCredentialledCourseConfig(courseID);
+  for (const rQ of cfg.questionTypes) {
+    if (rQ.name === questionViewName) {
+      for (const view of rQ.viewList) {
+        await addCard(
+          courseID,
+          dsDescriptor.course,
+          [noteID],
+          import_common2.NameSpacer.getViewString({
+            course: qDescriptor.course,
+            questionType: qDescriptor.questionType,
+            view
+          }),
+          elo,
+          tags,
+          author
+        );
+      }
+    }
+  }
+}
+async function addCard(courseID, course, id_displayable_data, id_view, elo, tags, author) {
+  const db = getCourseDB(courseID);
+  const card = await db.post({
+    course,
+    id_displayable_data,
+    id_view,
+    docType: "CARD" /* CARD */,
+    elo: elo || (0, import_common3.toCourseElo)(990 + Math.round(20 * Math.random())),
+    author
+  });
+  for (const tag of tags) {
+    logger.info(`adding tag: ${tag} to card ${card.id}`);
+    await addTagToCard(courseID, card.id, tag, author, false);
+  }
+  return card;
+}
+async function getCredentialledCourseConfig(courseID) {
+  try {
+    const db = getCourseDB(courseID);
+    const ret = await db.get("CourseConfig");
+    ret.courseID = courseID;
+    logger.info(`Returning course config: ${JSON.stringify(ret)}`);
+    return ret;
+  } catch (e) {
+    logger.error(`Error fetching config for ${courseID}:`, e);
+    throw e;
+  }
+}
+async function addTagToCard(courseID, cardID, tagID, author, updateELO = true) {
+  const prefixedTagID = getTagID(tagID);
+  const courseDB = getCourseDB(courseID);
+  const courseApi = new CourseDB(courseID, async () => {
+    const dummySyncStrategy = {
+      setupRemoteDB: () => null,
+      startSync: () => {
+      },
+      canCreateAccount: () => false,
+      canAuthenticate: () => false,
+      getCurrentUsername: async () => "DummyUser"
+    };
+    return BaseUser.Dummy(dummySyncStrategy);
+  });
+  try {
+    logger.info(`Applying tag ${tagID} to card ${courseID + "-" + cardID}...`);
+    const tag = await courseDB.get(prefixedTagID);
+    if (!tag.taggedCards.includes(cardID)) {
+      tag.taggedCards.push(cardID);
+      if (updateELO) {
+        try {
+          const eloData = await courseApi.getCardEloData([cardID]);
+          const elo = eloData[0];
+          elo.tags[tagID] = {
+            count: 0,
+            score: elo.global.score
+            // todo: or 1000?
+          };
+          await updateCardElo(courseID, cardID, elo);
+        } catch (error) {
+          logger.error("Failed to update ELO data for card:", cardID, error);
+        }
+      }
+      return courseDB.put(tag);
+    } else throw new AlreadyTaggedErr(`Card ${cardID} is already tagged with ${tagID}`);
+  } catch (e) {
+    if (e instanceof AlreadyTaggedErr) {
+      throw e;
+    }
+    await createTag(courseID, tagID, author);
+    return addTagToCard(courseID, cardID, tagID, author, updateELO);
+  }
+}
+async function updateCardElo(courseID, cardID, elo) {
+  if (elo) {
+    const cDB = getCourseDB(courseID);
+    const card = await cDB.get(cardID);
+    logger.debug(`Replacing ${JSON.stringify(card.elo)} with ${JSON.stringify(elo)}`);
+    card.elo = elo;
+    return cDB.put(card);
+  }
+}
+function getTagID(tagName) {
+  const tagPrefix = "TAG" /* TAG */.valueOf() + "-";
+  if (tagName.indexOf(tagPrefix) === 0) {
+    return tagName;
+  } else {
+    return tagPrefix + tagName;
+  }
+}
+function getCourseDB(courseID) {
+  const dbName = `coursedb-${courseID}`;
+  return new pouchdb_setup_default(
+    ENV.COUCHDB_SERVER_PROTOCOL + "://" + ENV.COUCHDB_SERVER_URL + dbName,
+    pouchDBincludeCredentialsConfig
+  );
+}
+var import_common2, import_common3, import_common4, AlreadyTaggedErr;
+var init_courseAPI = __esm({
+  "src/impl/couch/courseAPI.ts"() {
+    "use strict";
+    init_pouchdb_setup();
+    init_couch();
+    init_factory();
+    import_common2 = require("@vue-skuilder/common");
+    import_common3 = require("@vue-skuilder/common");
+    init_courseDB();
+    init_types_legacy();
+    import_common4 = require("@vue-skuilder/common");
+    init_common();
+    init_logger();
+    AlreadyTaggedErr = class extends Error {
+      constructor(message) {
+        super(message);
+        this.name = "AlreadyTaggedErr";
+      }
+    };
+  }
+});
+
+// src/impl/couch/courseLookupDB.ts
+var courseLookupDBTitle, CourseLookup;
+var init_courseLookupDB = __esm({
+  "src/impl/couch/courseLookupDB.ts"() {
+    "use strict";
+    init_pouchdb_setup();
+    init_factory();
+    init_logger();
+    courseLookupDBTitle = "coursedb-lookup";
+    logger.debug(`COURSELOOKUP FILE RUNNING`);
+    CourseLookup = class _CourseLookup {
+      // [ ] this db should be read only for public, admin-only for write
+      // Cache for the PouchDB instance
+      static _dbInstance = null;
+      /**
+       * Static getter for the PouchDB database instance.
+       * Connects using ENV variables and caches the instance.
+       * Throws an error if required ENV variables are not set.
+       */
+      static get _db() {
+        if (this._dbInstance) {
+          return this._dbInstance;
+        }
+        if (ENV.COUCHDB_SERVER_URL === "NOT_SET" || !ENV.COUCHDB_SERVER_URL) {
+          throw new Error(
+            "CourseLookup.db: COUCHDB_SERVER_URL is not set. Ensure initializeDataLayer has been called with valid configuration."
+          );
+        }
+        if (ENV.COUCHDB_SERVER_PROTOCOL === "NOT_SET" || !ENV.COUCHDB_SERVER_PROTOCOL) {
+          throw new Error(
+            "CourseLookup.db: COUCHDB_SERVER_PROTOCOL is not set. Ensure initializeDataLayer has been called with valid configuration."
+          );
+        }
+        const dbUrl = `${ENV.COUCHDB_SERVER_PROTOCOL}://${ENV.COUCHDB_SERVER_URL}/${courseLookupDBTitle}`;
+        const options = {
+          skip_setup: true
+          // Keep the original option
+          // fetch: (url, opts) => { // Optional: Add for debugging network requests
+          //   console.log('PouchDB fetch:', url, opts);
+          //   return pouch.fetch(url, opts);
+          // }
+        };
+        if (ENV.COUCHDB_USERNAME && ENV.COUCHDB_PASSWORD) {
+          options.auth = {
+            username: ENV.COUCHDB_USERNAME,
+            password: ENV.COUCHDB_PASSWORD
+          };
+          logger.info(`CourseLookup: Connecting to ${dbUrl} with authentication.`);
+        } else {
+          logger.info(`CourseLookup: Connecting to ${dbUrl} without authentication.`);
+        }
+        try {
+          this._dbInstance = new pouchdb_setup_default(dbUrl, options);
+          logger.info(`CourseLookup: Database instance created for ${courseLookupDBTitle}.`);
+          return this._dbInstance;
+        } catch (error) {
+          logger.error(`CourseLookup: Failed to create PouchDB instance for ${dbUrl}`, error);
+          this._dbInstance = null;
+          throw new Error(
+            `CourseLookup: Failed to initialize database connection: ${error instanceof Error ? error.message : String(error)}`
+          );
+        }
+      }
+      /**
+       * Adds a new course to the lookup database, and returns the courseID
+       * @param courseName
+       * @returns
+       */
+      static async add(courseName) {
+        const resp = await _CourseLookup._db.post({
+          name: courseName
+        });
+        return resp.id;
+      }
+      /**
+       * Removes a course from the index
+       * @param courseID
+       */
+      static async delete(courseID) {
+        const doc = await _CourseLookup._db.get(courseID);
+        return await _CourseLookup._db.remove(doc);
+      }
+      static async allCourses() {
+        const resp = await _CourseLookup._db.allDocs({
+          include_docs: true
+        });
+        return resp.rows.map((row) => row.doc);
+      }
+      static async updateDisambiguator(courseID, disambiguator) {
+        const doc = await _CourseLookup._db.get(courseID);
+        doc.disambiguator = disambiguator;
+        return await _CourseLookup._db.put(doc);
+      }
+      static async isCourse(courseID) {
+        try {
+          await _CourseLookup._db.get(courseID);
+          return true;
+        } catch (error) {
+          logger.info(`Courselookup failed:`, error);
+          return false;
+        }
+      }
+    };
+  }
+});
+
+// src/core/navigators/elo.ts
+var elo_exports = {};
+__export(elo_exports, {
+  default: () => ELONavigator
+});
+var ELONavigator;
+var init_elo = __esm({
+  "src/core/navigators/elo.ts"() {
+    "use strict";
+    init_navigators();
+    ELONavigator = class extends ContentNavigator {
+      user;
+      course;
+      constructor(user, course) {
+        super();
+        this.user = user;
+        this.course = course;
+      }
+      async getPendingReviews() {
+        const reviews = await this.user.getPendingReviews(this.course.getCourseID());
+        const elo = await this.course.getCardEloData(reviews.map((r) => r.cardId));
+        const ratedReviews = reviews.map((r, i) => {
+          const ratedR = {
+            ...r,
+            ...elo[i]
+          };
+          return ratedR;
+        });
+        ratedReviews.sort((a, b) => {
+          return a.global.score - b.global.score;
+        });
+        return ratedReviews.map((r) => {
+          return {
+            ...r,
+            contentSourceType: "course",
+            contentSourceID: this.course.getCourseID(),
+            cardID: r.cardId,
+            courseID: r.courseId,
+            qualifiedID: `${r.courseId}-${r.cardId}`,
+            reviewID: r._id,
+            status: "review"
+          };
+        });
+      }
+      async getNewCards(limit = 99) {
+        const activeCards = await this.user.getActiveCards();
+        return (await this.course.getCardsCenteredAtELO({ limit, elo: "user" }, (c) => {
+          if (activeCards.some((ac) => c.includes(ac))) {
+            return false;
+          } else {
+            return true;
+          }
+        })).map((c) => {
+          return {
+            ...c,
+            status: "new"
+          };
+        });
+      }
+    };
+  }
+});
+
+// import("./**/*") in src/core/navigators/index.ts
+var globImport;
+var init_ = __esm({
+  'import("./**/*") in src/core/navigators/index.ts'() {
+    globImport = __glob({
+      "./elo.ts": () => Promise.resolve().then(() => (init_elo(), elo_exports)),
+      "./index.ts": () => Promise.resolve().then(() => (init_navigators(), navigators_exports))
+    });
+  }
+});
+
+// src/core/navigators/index.ts
+var navigators_exports = {};
+__export(navigators_exports, {
+  ContentNavigator: () => ContentNavigator,
+  Navigators: () => Navigators
+});
+var Navigators, ContentNavigator;
+var init_navigators = __esm({
+  "src/core/navigators/index.ts"() {
+    "use strict";
+    init_logger();
+    init_();
+    Navigators = /* @__PURE__ */ ((Navigators2) => {
+      Navigators2["ELO"] = "elo";
+      return Navigators2;
+    })(Navigators || {});
+    ContentNavigator = class {
+      /**
+       *
+       * @param user
+       * @param strategyData
+       * @returns the runtime object used to steer a study session.
+       */
+      static async create(user, course, strategyData) {
+        const implementingClass = strategyData.implementingClass;
+        let NavigatorImpl;
+        const variations = ["", ".js", ".ts"];
+        for (const ext of variations) {
+          try {
+            const module2 = await globImport(`./${implementingClass}${ext}`);
+            NavigatorImpl = module2.default;
+            break;
+          } catch (e) {
+            logger.debug(`Failed to load with extension ${ext}:`, e);
+          }
+        }
+        if (!NavigatorImpl) {
+          throw new Error(`Could not load navigator implementation for: ${implementingClass}`);
+        }
+        return new NavigatorImpl(user, course, strategyData);
+      }
+    };
+  }
+});
+
+// src/impl/couch/courseDB.ts
+function randIntWeightedTowardZero(n) {
+  return Math.floor(Math.random() * Math.random() * Math.random() * n);
+}
+async function getCourseDataShapes(courseID) {
+  const cfg = await getCredentialledCourseConfig(courseID);
+  return cfg.dataShapes;
+}
+async function getCredentialledDataShapes(courseID) {
+  const cfg = await getCredentialledCourseConfig(courseID);
+  return cfg.dataShapes;
+}
+async function getCourseQuestionTypes(courseID) {
+  const cfg = await getCredentialledCourseConfig(courseID);
+  return cfg.questionTypes;
+}
+async function getCourseTagStubs(courseID) {
+  logger.debug(`Getting tag stubs for course: ${courseID}`);
+  const stubs = await filterAllDocsByPrefix2(
+    getCourseDB2(courseID),
+    "TAG" /* TAG */.valueOf() + "-"
+  );
+  stubs.rows.forEach((row) => {
+    logger.debug(`	Tag stub for doc: ${row.id}`);
+  });
+  return stubs;
+}
+async function deleteTag(courseID, tagName) {
+  tagName = getTagID(tagName);
+  const courseDB = getCourseDB2(courseID);
+  const doc = await courseDB.get("TAG" /* TAG */.valueOf() + "-" + tagName);
+  const resp = await courseDB.remove(doc);
+  return resp;
+}
+async function createTag(courseID, tagName, author) {
+  logger.debug(`Creating tag: ${tagName}...`);
+  const tagID = getTagID(tagName);
+  const courseDB = getCourseDB2(courseID);
+  const resp = await courseDB.put({
+    course: courseID,
+    docType: "TAG" /* TAG */,
+    name: tagName,
+    snippet: "",
+    taggedCards: [],
+    wiki: "",
+    author,
+    _id: tagID
+  });
+  return resp;
+}
+async function updateTag(tag) {
+  const prior = await getTag(tag.course, tag.name);
+  return await getCourseDB2(tag.course).put({
+    ...tag,
+    _rev: prior._rev
+  });
+}
+async function getTag(courseID, tagName) {
+  const tagID = getTagID(tagName);
+  const courseDB = getCourseDB2(courseID);
+  return courseDB.get(tagID);
+}
+async function removeTagFromCard(courseID, cardID, tagID) {
+  tagID = getTagID(tagID);
+  const courseDB = getCourseDB2(courseID);
+  const tag = await courseDB.get(tagID);
+  tag.taggedCards = tag.taggedCards.filter((taggedID) => {
+    return cardID !== taggedID;
+  });
+  return courseDB.put(tag);
+}
+function getAncestorTagIDs(courseID, tagID) {
+  tagID = getTagID(tagID);
+  const split = tagID.split(">");
+  if (split.length === 1) {
+    return [];
+  } else {
+    split.pop();
+    const parent = split.join(">");
+    return [parent].concat(getAncestorTagIDs(courseID, parent));
+  }
+}
+async function getChildTagStubs(courseID, tagID) {
+  return await filterAllDocsByPrefix2(getCourseDB2(courseID), tagID + ">");
+}
+async function getAppliedTags(id_course, id_card) {
+  const db = getCourseDB2(id_course);
+  const result = await db.query("getTags", {
+    startkey: id_card,
+    endkey: id_card
+    // include_docs: true
+  });
+  return result;
+}
+async function updateCardElo2(courseID, cardID, elo) {
+  if (elo) {
+    const cDB = getCourseDB2(courseID);
+    const card = await cDB.get(cardID);
+    logger.debug(`Replacing ${JSON.stringify(card.elo)} with ${JSON.stringify(elo)}`);
+    card.elo = elo;
+    return cDB.put(card);
+  }
+}
+async function updateCredentialledCourseConfig(courseID, config) {
+  logger.debug(`Updating course config:
+
+${JSON.stringify(config)}
+`);
+  const db = getCourseDB2(courseID);
+  const old = await getCredentialledCourseConfig(courseID);
+  return await db.put({
+    ...config,
+    _rev: old._rev
+  });
+}
+function isSuccessRow(row) {
+  return "doc" in row && row.doc !== null && row.doc !== void 0;
+}
+var import_common6, CoursesDB, CourseDB;
+var init_courseDB = __esm({
+  "src/impl/couch/courseDB.ts"() {
+    "use strict";
+    import_common6 = require("@vue-skuilder/common");
+    init_couch();
+    init_updateQueue();
+    init_types_legacy();
+    init_logger();
+    init_clientCache();
+    init_courseAPI();
+    init_courseLookupDB();
+    init_navigators();
+    CoursesDB = class {
+      _courseIDs;
+      constructor(courseIDs) {
+        if (courseIDs && courseIDs.length > 0) {
+          this._courseIDs = courseIDs;
+        } else {
+          this._courseIDs = void 0;
+        }
+      }
+      async getCourseList() {
+        let crsList = await CourseLookup.allCourses();
+        logger.debug(`AllCourses: ${crsList.map((c) => c.name + ", " + c._id + "\n	")}`);
+        if (this._courseIDs) {
+          crsList = crsList.filter((c) => this._courseIDs.includes(c._id));
+        }
+        logger.debug(`AllCourses.filtered: ${crsList.map((c) => c.name + ", " + c._id + "\n	")}`);
+        const cfgs = await Promise.all(
+          crsList.map(async (c) => {
+            try {
+              const cfg = await getCredentialledCourseConfig(c._id);
+              logger.debug(`Found cfg: ${JSON.stringify(cfg)}`);
+              return cfg;
+            } catch (e) {
+              logger.warn(`Error fetching cfg for course ${c.name}, ${c._id}: ${e}`);
+              return void 0;
+            }
+          })
+        );
+        return cfgs.filter((c) => !!c);
+      }
+      async getCourseConfig(courseId) {
+        if (this._courseIDs && this._courseIDs.length && !this._courseIDs.includes(courseId)) {
+          throw new Error(`Course ${courseId} not in course list`);
+        }
+        const cfg = await getCredentialledCourseConfig(courseId);
+        if (cfg === void 0) {
+          throw new Error(`Error fetching cfg for course ${courseId}`);
+        } else {
+          return cfg;
+        }
+      }
+      async disambiguateCourse(courseId, disambiguator) {
+        await CourseLookup.updateDisambiguator(courseId, disambiguator);
+      }
+    };
+    CourseDB = class {
+      // private log(msg: string): void {
+      //   log(`CourseLog: ${this.id}\n  ${msg}`);
+      // }
+      db;
+      id;
+      _getCurrentUser;
+      updateQueue;
+      constructor(id, userLookup) {
+        this.id = id;
+        this.db = getCourseDB2(this.id);
+        this._getCurrentUser = userLookup;
+        this.updateQueue = new UpdateQueue(this.db);
+      }
+      getCourseID() {
+        return this.id;
+      }
+      async getCourseInfo() {
+        const cardCount = (await this.db.find({
+          selector: {
+            docType: "CARD" /* CARD */
+          },
+          limit: 1e3
+        })).docs.length;
+        return {
+          cardCount,
+          registeredUsers: 0
+        };
+      }
+      async getInexperiencedCards(limit = 2) {
+        return (await this.db.query("cardsByInexperience", {
+          limit
+        })).rows.map((r) => {
+          const ret = {
+            courseId: this.id,
+            cardId: r.id,
+            count: r.key,
+            elo: r.value
+          };
+          return ret;
+        });
+      }
+      async getCardsByEloLimits(options = {
+        low: 0,
+        high: Number.MIN_SAFE_INTEGER,
+        limit: 25,
+        page: 0
+      }) {
+        return (await this.db.query("elo", {
+          startkey: options.low,
+          endkey: options.high,
+          limit: options.limit,
+          skip: options.limit * options.page
+        })).rows.map((r) => {
+          return `${this.id}-${r.id}-${r.key}`;
+        });
+      }
+      async getCardEloData(id) {
+        const docs = await this.db.allDocs({
+          keys: id,
+          include_docs: true
+        });
+        const ret = [];
+        docs.rows.forEach((r) => {
+          if (isSuccessRow(r)) {
+            if (r.doc && r.doc.elo) {
+              ret.push((0, import_common6.toCourseElo)(r.doc.elo));
+            } else {
+              logger.warn("no elo data for card: " + r.id);
+              ret.push((0, import_common6.blankCourseElo)());
+            }
+          } else {
+            logger.warn("no elo data for card: " + JSON.stringify(r));
+            ret.push((0, import_common6.blankCourseElo)());
+          }
+        });
+        return ret;
+      }
+      /**
+       * Returns the lowest and highest `global` ELO ratings in the course
+       */
+      async getELOBounds() {
+        const [low, high] = await Promise.all([
+          (await this.db.query("elo", {
+            startkey: 0,
+            limit: 1,
+            include_docs: false
+          })).rows[0].key,
+          (await this.db.query("elo", {
+            limit: 1,
+            descending: true,
+            startkey: 1e5
+          })).rows[0].key
+        ]);
+        return {
+          low,
+          high
+        };
+      }
+      async removeCard(id) {
+        const doc = await this.db.get(id);
+        if (!doc.docType || !(doc.docType === "CARD" /* CARD */)) {
+          throw new Error(`failed to remove ${id} from course ${this.id}. id does not point to a card`);
+        }
+        return this.db.remove(doc);
+      }
+      async getCardDisplayableDataIDs(id) {
+        logger.debug(id.join(", "));
+        const cards = await this.db.allDocs({
+          keys: id,
+          include_docs: true
+        });
+        const ret = {};
+        cards.rows.forEach((r) => {
+          if (isSuccessRow(r)) {
+            ret[r.id] = r.doc.id_displayable_data;
+          }
+        });
+        await Promise.all(
+          cards.rows.map((r) => {
+            return async () => {
+              if (isSuccessRow(r)) {
+                ret[r.id] = r.doc.id_displayable_data;
+              }
+            };
+          })
+        );
+        return ret;
+      }
+      async getCardsByELO(elo, cardLimit) {
+        elo = parseInt(elo);
+        const limit = cardLimit ? cardLimit : 25;
+        const below = await this.db.query("elo", {
+          limit: Math.ceil(limit / 2),
+          startkey: elo,
+          descending: true
+        });
+        const aboveLimit = limit - below.rows.length;
+        const above = await this.db.query("elo", {
+          limit: aboveLimit,
+          startkey: elo + 1
+        });
+        let cards = below.rows;
+        cards = cards.concat(above.rows);
+        const ret = cards.sort((a, b) => {
+          const s = Math.abs(a.key - elo) - Math.abs(b.key - elo);
+          if (s === 0) {
+            return Math.random() - 0.5;
+          } else {
+            return s;
+          }
+        }).map((c) => `${this.id}-${c.id}-${c.key}`);
+        const str = `below:
+${below.rows.map((r) => `	${r.id}-${r.key}
+`)}
+
+above:
+${above.rows.map((r) => `	${r.id}-${r.key}
+`)}`;
+        logger.debug(`Getting ${limit} cards centered around elo: ${elo}:
+
+` + str);
+        return ret;
+      }
+      async getCourseConfig() {
+        const ret = await getCredentialledCourseConfig(this.id);
+        if (ret) {
+          return ret;
+        } else {
+          throw new Error(`Course config not found for course ID: ${this.id}`);
+        }
+      }
+      async updateCourseConfig(cfg) {
+        logger.debug(`Updating: ${JSON.stringify(cfg)}`);
+        try {
+          return await updateCredentialledCourseConfig(this.id, cfg);
+        } catch (error) {
+          logger.error(`Error updating course config in course DB: ${error}`);
+          throw error;
+        }
+      }
+      async updateCardElo(cardId, elo) {
+        if (!elo) {
+          throw new Error(`Cannot update card elo with null or undefined value for card ID: ${cardId}`);
+        }
+        try {
+          const result = await this.updateQueue.update(cardId, (card) => {
+            logger.debug(`Replacing ${JSON.stringify(card.elo)} with ${JSON.stringify(elo)}`);
+            card.elo = elo;
+            return card;
+          });
+          return { ok: true, id: cardId, rev: result._rev };
+        } catch (error) {
+          logger.error(`Failed to update card elo for card ID: ${cardId}`, error);
+          throw new Error(`Failed to update card elo for card ID: ${cardId}`);
+        }
+      }
+      async getAppliedTags(cardId) {
+        const ret = await getAppliedTags(this.id, cardId);
+        if (ret) {
+          return ret;
+        } else {
+          throw new Error(`Failed to find tags for card ${this.id}-${cardId}`);
+        }
+      }
+      async addTagToCard(cardId, tagId, updateELO) {
+        return await addTagToCard(this.id, cardId, tagId, (await this._getCurrentUser()).getUsername(), updateELO);
+      }
+      async removeTagFromCard(cardId, tagId) {
+        return await removeTagFromCard(this.id, cardId, tagId);
+      }
+      async createTag(name, author) {
+        return await createTag(this.id, name, author);
+      }
+      async getTag(tagId) {
+        return await getTag(this.id, tagId);
+      }
+      async updateTag(tag) {
+        if (tag.course !== this.id) {
+          throw new Error(`Tag ${JSON.stringify(tag)} does not belong to course ${this.id}`);
+        }
+        return await updateTag(tag);
+      }
+      async getCourseTagStubs() {
+        return getCourseTagStubs(this.id);
+      }
+      async addNote(codeCourse, shape, data, author, tags, uploads, elo = (0, import_common6.blankCourseElo)()) {
+        try {
+          const resp = await addNote55(this.id, codeCourse, shape, data, author, tags, uploads, elo);
+          if (resp.ok) {
+            if (resp.cardCreationFailed) {
+              logger.warn(
+                `[courseDB.addNote] Note added but card creation failed: ${resp.cardCreationError}`
+              );
+              return {
+                status: import_common6.Status.error,
+                message: `Note was added but no cards were created: ${resp.cardCreationError}`,
+                id: resp.id
+              };
+            }
+            return {
+              status: import_common6.Status.ok,
+              message: "",
+              id: resp.id
+            };
+          } else {
+            return {
+              status: import_common6.Status.error,
+              message: "Unexpected error adding note"
+            };
+          }
+        } catch (e) {
+          const err = e;
+          logger.error(
+            `[addNote] error ${err.name}
+	reason: ${err.reason}
+	message: ${err.message}`
+          );
+          return {
+            status: import_common6.Status.error,
+            message: `Error adding note to course. ${e.reason || err.message}`
+          };
+        }
+      }
+      async getCourseDoc(id, options) {
+        return await getCourseDoc(this.id, id, options);
+      }
+      async getCourseDocs(ids, options = {}) {
+        return await getCourseDocs(this.id, ids, options);
+      }
+      ////////////////////////////////////
+      // NavigationStrategyManager implementation
+      ////////////////////////////////////
+      getNavigationStrategy(id) {
+        logger.debug(`[courseDB] Getting navigation strategy: ${id}`);
+        const strategy = {
+          id: "ELO",
+          docType: "NAVIGATION_STRATEGY" /* NAVIGATION_STRATEGY */,
+          name: "ELO",
+          description: "ELO-based navigation strategy for ordering content by difficulty",
+          implementingClass: "elo" /* ELO */,
+          course: this.id,
+          serializedData: ""
+          // serde is a noop for ELO navigator.
+        };
+        return Promise.resolve(strategy);
+      }
+      getAllNavigationStrategies() {
+        logger.debug("[courseDB] Returning hard-coded navigation strategies");
+        const strategies = [
+          {
+            id: "ELO",
+            docType: "NAVIGATION_STRATEGY" /* NAVIGATION_STRATEGY */,
+            name: "ELO",
+            description: "ELO-based navigation strategy for ordering content by difficulty",
+            implementingClass: "elo" /* ELO */,
+            course: this.id,
+            serializedData: ""
+            // serde is a noop for ELO navigator.
+          }
+        ];
+        return Promise.resolve(strategies);
+      }
+      addNavigationStrategy(data) {
+        logger.debug(`[courseDB] Adding navigation strategy: ${data.id}`);
+        logger.debug(JSON.stringify(data));
+        return Promise.resolve();
+      }
+      updateNavigationStrategy(id, data) {
+        logger.debug(`[courseDB] Updating navigation strategy: ${id}`);
+        logger.debug(JSON.stringify(data));
+        return Promise.resolve();
+      }
+      async surfaceNavigationStrategy() {
+        logger.warn(`Returning hard-coded default ELO navigator`);
+        const ret = {
+          id: "ELO",
+          docType: "NAVIGATION_STRATEGY" /* NAVIGATION_STRATEGY */,
+          name: "ELO",
+          description: "ELO-based navigation strategy",
+          implementingClass: "elo" /* ELO */,
+          course: this.id,
+          serializedData: ""
+          // serde is a noop for ELO navigator.
+        };
+        return Promise.resolve(ret);
+      }
+      ////////////////////////////////////
+      // END NavigationStrategyManager implementation
+      ////////////////////////////////////
+      ////////////////////////////////////
+      // StudyContentSource implementation
+      ////////////////////////////////////
+      async getNewCards(limit = 99) {
+        const u = await this._getCurrentUser();
+        try {
+          const strategy = await this.surfaceNavigationStrategy();
+          const navigator = await ContentNavigator.create(u, this, strategy);
+          return navigator.getNewCards(limit);
+        } catch (e) {
+          logger.error(`[courseDB] Error surfacing a NavigationStrategy: ${e}`);
+          throw e;
+        }
+      }
+      async getPendingReviews() {
+        const u = await this._getCurrentUser();
+        try {
+          const strategy = await this.surfaceNavigationStrategy();
+          const navigator = await ContentNavigator.create(u, this, strategy);
+          return navigator.getPendingReviews();
+        } catch (e) {
+          logger.error(`[courseDB] Error surfacing a NavigationStrategy: ${e}`);
+          throw e;
+        }
+      }
+      async getCardsCenteredAtELO(options = {
+        limit: 99,
+        elo: "user"
+      }, filter) {
+        let targetElo;
+        if (options.elo === "user") {
+          const u = await this._getCurrentUser();
+          targetElo = -1;
+          try {
+            const courseDoc = (await u.getCourseRegistrationsDoc()).courses.find((c) => {
+              return c.courseID === this.id;
+            });
+            targetElo = (0, import_common6.EloToNumber)(courseDoc.elo);
+          } catch {
+            targetElo = 1e3;
+          }
+        } else if (options.elo === "random") {
+          const bounds = await GET_CACHED(`elo-bounds-${this.id}`, () => this.getELOBounds());
+          targetElo = Math.round(bounds.low + Math.random() * (bounds.high - bounds.low));
+        } else {
+          targetElo = options.elo;
+        }
+        let cards = [];
+        let mult = 4;
+        let previousCount = -1;
+        let newCount = 0;
+        while (cards.length < options.limit && newCount !== previousCount) {
+          cards = await this.getCardsByELO(targetElo, mult * options.limit);
+          previousCount = newCount;
+          newCount = cards.length;
+          logger.debug(`Found ${cards.length} elo neighbor cards...`);
+          if (filter) {
+            cards = cards.filter(filter);
+            logger.debug(`Filtered to ${cards.length} cards...`);
+          }
+          mult *= 2;
+        }
+        const selectedCards = [];
+        while (selectedCards.length < options.limit && cards.length > 0) {
+          const index = randIntWeightedTowardZero(cards.length);
+          const card = cards.splice(index, 1)[0];
+          selectedCards.push(card);
+        }
+        return selectedCards.map((c) => {
+          const split = c.split("-");
+          return {
+            courseID: this.id,
+            cardID: split[1],
+            qualifiedID: `${split[0]}-${split[1]}`,
+            contentSourceType: "course",
+            contentSourceID: this.id,
+            status: "new"
+          };
+        });
+      }
+    };
+  }
+});
+
+// src/impl/couch/classroomDB.ts
+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}`;
+        } else {
+          return `${this._content_prefix}-${content.courseID}`;
+        }
+      }
+      get ready() {
+        return this._initComplete;
+      }
+      getConfig() {
+        return this._cfg;
+      }
+    };
+    StudentClassroomDB = class _StudentClassroomDB extends ClassroomDBBase {
+      // private readonly _prefix: string = 'content';
+      userMessages;
+      _user;
+      constructor(classID, user) {
+        super();
+        this._id = classID;
+        this._user = user;
+      }
+      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)}`);
+        }
+      }
+      static async factory(classID, user) {
+        const ret = new _StudentClassroomDB(classID, user);
+        await ret.init();
+        return ret;
+      }
+      setChangeFcn(f) {
+        void this.userMessages.on("change", f);
+      }
+      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 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));
+          }
+        }
+        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;
+          }
+        });
+      }
+    };
+    TeacherClassroomDB = class _TeacherClassroomDB extends ClassroomDBBase {
+      _stuDb;
+      constructor(classID) {
+        super();
+        this._id = classID;
+      }
+      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 {
+          return this._db.get(CLASSROOM_CONFIG).then((cfg) => {
+            this._cfg = cfg;
+            this._initComplete = true;
+          }).then(() => {
+            return;
+          });
+        } catch (e) {
+          throw new Error(`Error in TeacherClassroomDB constructor: ${JSON.stringify(e)}`);
+        }
+      }
+      static async factory(classID) {
+        const ret = new _TeacherClassroomDB(classID);
+        await ret.init();
+        return ret;
+      }
+      async removeContent(content) {
+        const contentID = this.getContentId(content);
+        try {
+          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 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;
+        }
+      }
+    };
+    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_classroomDB();
+  }
+});
+
+// src/impl/couch/adminDB.ts
+var AdminDB;
+var init_adminDB = __esm({
+  "src/impl/couch/adminDB.ts"() {
+    "use strict";
+    init_pouchdb_setup();
+    init_factory();
+    init_couch();
+    init_classroomDB();
+    init_courseLookupDB();
+    init_logger();
+    AdminDB = class {
+      usersDB;
+      constructor() {
+        this.usersDB = new pouchdb_setup_default(
+          ENV.COUCHDB_SERVER_PROTOCOL + "://" + ENV.COUCHDB_SERVER_URL + "_users",
+          pouchDBincludeCredentialsConfig
+        );
+      }
+      async getUsers() {
+        return (await this.usersDB.allDocs({
+          include_docs: true,
+          ...getStartAndEndKeys2("org.couchdb.user:")
+        })).rows.map((r) => r.doc);
+      }
+      async getCourses() {
+        const list = await CourseLookup.allCourses();
+        return await Promise.all(
+          list.map((c) => {
+            return getCredentialledCourseConfig(c._id);
+          })
+        );
+      }
+      async removeCourse(id) {
+        const delResp = await CourseLookup.delete(id);
+        const cfg = await getCredentialledCourseConfig(id);
+        cfg.deleted = true;
+        const isDeletedResp = await updateCredentialledCourseConfig(id, cfg);
+        return {
+          ok: delResp.ok && isDeletedResp.ok,
+          id: delResp.id,
+          rev: delResp.rev
+        };
+      }
+      async getClassrooms() {
+        const uuids = (await ClassroomLookupDB().allDocs({
+          include_docs: true
+        })).rows.map((r) => r.doc.uuid);
+        logger.debug(uuids.join(", "));
+        const promisedCRDbs = [];
+        for (let i = 0; i < uuids.length; i++) {
+          try {
+            const db = await TeacherClassroomDB.factory(uuids[i]);
+            promisedCRDbs.push(db);
+          } catch (e) {
+            const err = e;
+            if (err.error && err.error === "not_found") {
+              logger.warn(`db ${uuids[i]} not found`);
+            }
+          }
+        }
+        const dbs = await Promise.all(promisedCRDbs);
+        return dbs.map((db) => {
+          return {
+            ...db.getConfig(),
+            _id: db._id
+          };
+        });
+      }
+    };
+  }
+});
+
+// src/impl/couch/auth.ts
+async function getCurrentSession() {
+  return new Promise((resolve, reject) => {
+    const authXML = new XMLHttpRequest();
+    authXML.withCredentials = true;
+    authXML.onerror = (e) => {
+      reject(new Error("Session check failed:", e));
+    };
+    authXML.addEventListener("load", () => {
+      try {
+        const resp = JSON.parse(authXML.responseText);
+        resolve(resp);
+      } catch (e) {
+        reject(e);
+      }
+    });
+    const url = `${ENV.COUCHDB_SERVER_PROTOCOL}://${ENV.COUCHDB_SERVER_URL}_session`;
+    authXML.open("GET", url);
+    authXML.send();
+  });
+}
+async function getLoggedInUsername() {
+  try {
+    const session = await getCurrentSession();
+    if (session.userCtx.name && session.userCtx.name !== "") {
+      return session.userCtx.name;
+    }
+  } catch (error) {
+    logger.error("Failed to get session:", error);
+  }
+  return GuestUsername;
+}
+var init_auth = __esm({
+  "src/impl/couch/auth.ts"() {
+    "use strict";
+    init_factory();
+    init_types_legacy();
+    init_logger();
+  }
+});
+
+// src/impl/couch/CouchDBSyncStrategy.ts
+var import_common7, log4, CouchDBSyncStrategy;
+var init_CouchDBSyncStrategy = __esm({
+  "src/impl/couch/CouchDBSyncStrategy.ts"() {
+    "use strict";
+    init_factory();
+    init_types_legacy();
+    init_logger();
+    import_common7 = require("@vue-skuilder/common");
+    init_common();
+    init_pouchdb_setup();
+    init_couch();
+    init_auth();
+    log4 = (s) => {
+      logger.info(s);
+    };
+    CouchDBSyncStrategy = class {
+      syncHandle;
+      // Handle to cancel sync if needed
+      setupRemoteDB(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, {
+            live: true,
+            retry: true
+          });
+        }
+      }
+      stopSync() {
+        if (this.syncHandle) {
+          this.syncHandle.cancel();
+          this.syncHandle = void 0;
+        }
+      }
+      canCreateAccount() {
+        return true;
+      }
+      canAuthenticate() {
+        return true;
+      }
+      async createAccount(username, password) {
+        try {
+          const signupRequest = await this.getRemoteCouchRootDB().signUp(username, password);
+          if (signupRequest.ok) {
+            log4(`CREATEACCOUNT: Successfully created account for ${username}`);
+            try {
+              const logoutResult = await this.getRemoteCouchRootDB().logOut();
+              log4(`CREATEACCOUNT: logged out: ${logoutResult.ok}`);
+            } catch {
+            }
+            const loginResult = await this.getRemoteCouchRootDB().logIn(username, password);
+            log4(`CREATEACCOUNT: logged in as new user: ${loginResult.ok}`);
+            if (loginResult.ok) {
+              return {
+                status: import_common7.Status.ok,
+                error: void 0
+              };
+            } else {
+              return {
+                status: import_common7.Status.error,
+                error: "Failed to log in after account creation"
+              };
+            }
+          } else {
+            logger.warn(`Signup not OK: ${JSON.stringify(signupRequest)}`);
+            return {
+              status: import_common7.Status.error,
+              error: "Account creation failed"
+            };
+          }
+        } catch (e) {
+          if (e.reason === "Document update conflict.") {
+            return {
+              status: import_common7.Status.error,
+              error: "This username is taken!"
+            };
+          }
+          logger.error(`Error on signup: ${JSON.stringify(e)}`);
+          return {
+            status: import_common7.Status.error,
+            error: e.message || "Unknown error during account creation"
+          };
+        }
+      }
+      async authenticate(username, password) {
+        try {
+          const loginResult = await this.getRemoteCouchRootDB().logIn(username, password);
+          if (loginResult.ok) {
+            log4(`Successfully logged in as ${username}`);
+            return {
+              ok: true
+            };
+          } else {
+            log4(`Login failed for ${username}`);
+            return {
+              ok: false,
+              error: "Invalid username or password"
+            };
+          }
+        } catch (error) {
+          logger.error(`Authentication error for ${username}:`, error);
+          return {
+            ok: false,
+            error: error.message || "Authentication failed"
+          };
+        }
+      }
+      async logout() {
+        try {
+          const result = await this.getRemoteCouchRootDB().logOut();
+          return {
+            ok: result.ok,
+            error: result.ok ? void 0 : "Logout failed"
+          };
+        } catch (error) {
+          logger.error("Logout error:", error);
+          return {
+            ok: false,
+            error: error.message || "Logout failed"
+          };
+        }
+      }
+      async getCurrentUsername() {
+        try {
+          return await getLoggedInUsername();
+        } catch {
+          return GuestUsername;
+        }
+      }
+      /**
+       * Get remote CouchDB root database for authentication operations
+       */
+      getRemoteCouchRootDB() {
+        const remoteStr = ENV.COUCHDB_SERVER_PROTOCOL + "://" + ENV.COUCHDB_SERVER_URL + "skuilder";
+        try {
+          return new pouchdb_setup_default(remoteStr, {
+            skip_setup: true
+          });
+        } catch (error) {
+          logger.error("Failed to initialize remote CouchDB connection:", error);
+          throw new Error(`Failed to initialize CouchDB: ${JSON.stringify(error)}`);
+        }
+      }
+      /**
+       * Get remote user database for a specific user
+       */
+      getUserDB(username) {
+        const guestAccount = false;
+        const hexName = hexEncode(username);
+        const dbName = `userdb-${hexName}`;
+        log4(`Fetching user database: ${dbName} (${username})`);
+        const ret = new pouchdb_setup_default(
+          ENV.COUCHDB_SERVER_PROTOCOL + "://" + ENV.COUCHDB_SERVER_URL + dbName,
+          pouchDBincludeCredentialsConfig
+        );
+        if (guestAccount) {
+          updateGuestAccountExpirationDate(ret);
+        }
+        return ret;
+      }
+    };
+  }
+});
+
+// src/impl/couch/index.ts
+var couch_exports = {};
+__export(couch_exports, {
+  AdminDB: () => AdminDB,
+  CLASSROOM_CONFIG: () => CLASSROOM_CONFIG,
+  ClassroomLookupDB: () => ClassroomLookupDB,
+  CouchDBSyncStrategy: () => CouchDBSyncStrategy,
+  CourseDB: () => CourseDB,
+  CoursesDB: () => CoursesDB,
+  REVIEW_PREFIX: () => REVIEW_PREFIX2,
+  REVIEW_TIME_FORMAT: () => REVIEW_TIME_FORMAT2,
+  StudentClassroomDB: () => StudentClassroomDB,
+  TeacherClassroomDB: () => TeacherClassroomDB,
+  addNote55: () => addNote55,
+  addTagToCard: () => addTagToCard,
+  createTag: () => createTag,
+  deleteTag: () => deleteTag,
+  filterAllDocsByPrefix: () => filterAllDocsByPrefix2,
+  getAncestorTagIDs: () => getAncestorTagIDs,
+  getAppliedTags: () => getAppliedTags,
+  getChildTagStubs: () => getChildTagStubs,
+  getClassroomConfig: () => getClassroomConfig,
+  getClassroomDB: () => getClassroomDB,
+  getCouchUserDB: () => getCouchUserDB,
+  getCourseDB: () => getCourseDB2,
+  getCourseDataShapes: () => getCourseDataShapes,
+  getCourseDoc: () => getCourseDoc,
+  getCourseDocs: () => getCourseDocs,
+  getCourseQuestionTypes: () => getCourseQuestionTypes,
+  getCourseTagStubs: () => getCourseTagStubs,
+  getCredentialledCourseConfig: () => getCredentialledCourseConfig,
+  getCredentialledDataShapes: () => getCredentialledDataShapes,
+  getLatestVersion: () => getLatestVersion,
+  getRandomCards: () => getRandomCards,
+  getStartAndEndKeys: () => getStartAndEndKeys2,
+  getStudySource: () => getStudySource,
+  getTag: () => getTag,
+  getTagID: () => getTagID,
+  hexEncode: () => hexEncode2,
+  isReview: () => isReview,
+  localUserDB: () => localUserDB,
+  pouchDBincludeCredentialsConfig: () => pouchDBincludeCredentialsConfig,
+  removeTagFromCard: () => removeTagFromCard,
+  scheduleCardReview: () => scheduleCardReview,
+  updateCardElo: () => updateCardElo2,
+  updateCredentialledCourseConfig: () => updateCredentialledCourseConfig,
+  updateGuestAccountExpirationDate: () => updateGuestAccountExpirationDate2,
+  updateTag: () => updateTag,
+  usernameIsAvailable: () => usernameIsAvailable
+});
+module.exports = __toCommonJS(couch_exports);
+function hexEncode2(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 getCouchDB(dbName) {
+  return new pouchdb_setup_default(
+    ENV.COUCHDB_SERVER_PROTOCOL + "://" + ENV.COUCHDB_SERVER_URL + dbName,
+    pouchDBincludeCredentialsConfig
+  );
+}
+function getCourseDB2(courseID) {
+  return new pouchdb_setup_default(
+    ENV.COUCHDB_SERVER_PROTOCOL + "://" + ENV.COUCHDB_SERVER_URL + "coursedb-" + courseID,
+    pouchDBincludeCredentialsConfig
+  );
+}
+async function getLatestVersion() {
+  try {
+    const docs = await getCouchDB("version").allDocs({
+      descending: true,
+      limit: 1
+    });
+    if (docs && docs.rows && docs.rows[0]) {
+      return docs.rows[0].id;
+    } else {
+      return "0.0.0";
+    }
+  } catch {
+    return "-1";
+  }
+}
+async function usernameIsAvailable(username) {
+  log(`Checking availability of ${username}`);
+  const req = new XMLHttpRequest();
+  const url = ENV.COUCHDB_SERVER_URL + "userdb-" + hexEncode2(username);
+  req.open("HEAD", url, false);
+  req.send();
+  return req.status === 404;
+}
+function updateGuestAccountExpirationDate2(guestDB) {
+  const currentTime = import_moment5.default.utc();
+  const expirationDate = currentTime.add(2, "months").toISOString();
+  void guestDB.get(expiryDocID).then((doc) => {
+    return guestDB.put({
+      _id: expiryDocID,
+      _rev: doc._rev,
+      date: expirationDate
+    });
+  }).catch(() => {
+    return guestDB.put({
+      _id: expiryDocID,
+      date: expirationDate
+    });
+  });
+}
+function getCourseDocs(courseID, docIDs, options = {}) {
+  return getCourseDB2(courseID).allDocs({
+    ...options,
+    keys: docIDs
+  });
+}
+function getCourseDoc(courseID, docID, options = {}) {
+  return getCourseDB2(courseID).get(docID, options);
+}
+async function getRandomCards(courseIDs) {
+  if (courseIDs.length === 0) {
+    throw new Error(`getRandomCards:
+	Attempted to get all cards from no courses!`);
+  } else {
+    const courseResults = await Promise.all(
+      courseIDs.map((course) => {
+        return getCourseDB2(course).find({
+          selector: {
+            docType: "CARD" /* CARD */
+          },
+          limit: 1e3
+        });
+      })
+    );
+    const ret = [];
+    courseResults.forEach((courseCards, index) => {
+      courseCards.docs.forEach((doc) => {
+        ret.push(`${courseIDs[index]}-${doc._id}`);
+      });
+    });
+    return ret;
+  }
+}
+function getCouchUserDB(username) {
+  const guestAccount = false;
+  const hexName = hexEncode2(username);
+  const dbName = `userdb-${hexName}`;
+  log(`Fetching user database: ${dbName} (${username})`);
+  const ret = new pouchdb_setup_default(
+    ENV.COUCHDB_SERVER_PROTOCOL + "://" + ENV.COUCHDB_SERVER_URL + dbName,
+    pouchDBincludeCredentialsConfig
+  );
+  if (guestAccount) {
+    updateGuestAccountExpirationDate2(ret);
+  }
+  return ret;
+}
+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),
+    cardId: review.card_id,
+    reviewTime: review.time,
+    courseId: review.course_id,
+    scheduledAt: now,
+    scheduledFor: review.scheduledFor,
+    schedulingAgentId: review.schedulingAgentId
+  });
+}
+function filterAllDocsByPrefix2(db, prefix, opts) {
+  const options = {
+    startkey: prefix,
+    endkey: prefix + "\uFFF0",
+    include_docs: true
+  };
+  if (opts) {
+    Object.assign(options, opts);
+  }
+  return db.allDocs(options);
+}
+function getStartAndEndKeys2(key) {
+  return {
+    startkey: key,
+    endkey: key + "\uFFF0"
+  };
+}
+var import_moment5, import_process, isBrowser, expiryDocID, GUEST_LOCAL_DB, localUserDB, pouchDBincludeCredentialsConfig, REVIEW_PREFIX2, REVIEW_TIME_FORMAT2;
+var init_couch = __esm({
+  "src/impl/couch/index.ts"() {
+    init_factory();
+    init_types_legacy();
+    import_moment5 = __toESM(require("moment"));
+    init_logger();
+    init_pouchdb_setup();
+    import_process = __toESM(require("process"));
+    init_contentSource();
+    init_adminDB();
+    init_classroomDB();
+    init_courseAPI();
+    init_courseDB();
+    init_CouchDBSyncStrategy();
+    isBrowser = typeof window !== "undefined";
+    if (isBrowser) {
+      window.process = import_process.default;
+    }
+    expiryDocID = "GuestAccountExpirationDate";
+    GUEST_LOCAL_DB = `userdb-${GuestUsername}`;
+    localUserDB = new pouchdb_setup_default(GUEST_LOCAL_DB);
+    pouchDBincludeCredentialsConfig = {
+      fetch(url, opts) {
+        opts.credentials = "include";
+        return pouchdb_setup_default.fetch(url, opts);
+      }
+    };
+    REVIEW_PREFIX2 = "card_review_";
+    REVIEW_TIME_FORMAT2 = "YYYY-MM-DD--kk:mm:ss-SSS";
+  }
+});
+init_couch();
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AdminDB,
+  CLASSROOM_CONFIG,
+  ClassroomLookupDB,
+  CouchDBSyncStrategy,
+  CourseDB,
+  CoursesDB,
+  REVIEW_PREFIX,
+  REVIEW_TIME_FORMAT,
+  StudentClassroomDB,
+  TeacherClassroomDB,
+  addNote55,
+  addTagToCard,
+  createTag,
+  deleteTag,
+  filterAllDocsByPrefix,
+  getAncestorTagIDs,
+  getAppliedTags,
+  getChildTagStubs,
+  getClassroomConfig,
+  getClassroomDB,
+  getCouchUserDB,
+  getCourseDB,
+  getCourseDataShapes,
+  getCourseDoc,
+  getCourseDocs,
+  getCourseQuestionTypes,
+  getCourseTagStubs,
+  getCredentialledCourseConfig,
+  getCredentialledDataShapes,
+  getLatestVersion,
+  getRandomCards,
+  getStartAndEndKeys,
+  getStudySource,
+  getTag,
+  getTagID,
+  hexEncode,
+  isReview,
+  localUserDB,
+  pouchDBincludeCredentialsConfig,
+  removeTagFromCard,
+  scheduleCardReview,
+  updateCardElo,
+  updateCredentialledCourseConfig,
+  updateGuestAccountExpirationDate,
+  updateTag,
+  usernameIsAvailable
+});
+//# sourceMappingURL=index.js.map