@vue-skuilder/db 0.1.11 → 0.1.12

package/dist/{types-DtoI27Xh.d.ts → types-CewsN87z.d.ts}

@@ -1,5 +1,5 @@
 import { CourseConfig } from '@vue-skuilder/common';
-import { D as DocType } from './types-legacy-B8ahaCbj.js';
+import { D as DocType } from './types-legacy-6ettoclI.js';
 
 interface StaticCourseManifest {
     version: string;

package/dist/{types-Che4wTwA.d.mts → types-Dbp5DaRR.d.mts}

@@ -1,5 +1,5 @@
 import { CourseConfig } from '@vue-skuilder/common';
-import { D as DocType } from './types-legacy-B8ahaCbj.mjs';
+import { D as DocType } from './types-legacy-6ettoclI.mjs';
 
 interface StaticCourseManifest {
     version: string;

package/dist/{types-legacy-B8ahaCbj.d.mts → types-legacy-6ettoclI.d.mts}

@@ -78,7 +78,18 @@ interface QuestionData extends SkuilderCourseData {
     viewList: string[];
     dataShapeList: PouchDB.Core.DocumentId[];
 }
-declare const DocTypePrefixes: Record<string, string>;
+declare const DocTypePrefixes: {
+    readonly CARD: "c";
+    readonly DISPLAYABLE_DATA: "dd";
+    readonly TAG: "TAG";
+    readonly CARDRECORD: "cardH";
+    readonly SCHEDULED_CARD: "card_review_";
+    readonly DATASHAPE: "DATASHAPE";
+    readonly QUESTION: "QUESTION";
+    readonly VIEW: "VIEW";
+    readonly PEDAGOGY: "PEDAGOGY";
+    readonly NAVIGATION_STRATEGY: "NAVIGATION_STRATEGY";
+};
 interface CardHistory<T extends CardRecord> {
     _id: PouchDB.Core.DocumentId;
     /**
@@ -140,4 +151,4 @@ interface QuestionRecord extends CardRecord, Evaluation {
     priorAttemps: number;
 }
 
-export { type CardRecord as C, DocType as D, type Field as F, GuestUsername as G, type QualifiedCardID as Q, type SkuilderCourseData as S, type TagStub as T, type Tag as a, type CardData as b, type CourseListData as c, type DisplayableData as d, type DataShapeData as e, type QuestionData as f, DocTypePrefixes as g, type CardHistory as h, type QuestionRecord as i, log as l };
+export { type CardHistory as C, DocType as D, type Field as F, GuestUsername as G, type QualifiedCardID as Q, type SkuilderCourseData as S, type TagStub as T, type Tag as a, DocTypePrefixes as b, type CardRecord as c, type CardData as d, type CourseListData as e, type DisplayableData as f, type DataShapeData as g, type QuestionData as h, type QuestionRecord as i, log as l };

package/dist/{types-legacy-B8ahaCbj.d.ts → types-legacy-6ettoclI.d.ts}

@@ -78,7 +78,18 @@ interface QuestionData extends SkuilderCourseData {
     viewList: string[];
     dataShapeList: PouchDB.Core.DocumentId[];
 }
-declare const DocTypePrefixes: Record<string, string>;
+declare const DocTypePrefixes: {
+    readonly CARD: "c";
+    readonly DISPLAYABLE_DATA: "dd";
+    readonly TAG: "TAG";
+    readonly CARDRECORD: "cardH";
+    readonly SCHEDULED_CARD: "card_review_";
+    readonly DATASHAPE: "DATASHAPE";
+    readonly QUESTION: "QUESTION";
+    readonly VIEW: "VIEW";
+    readonly PEDAGOGY: "PEDAGOGY";
+    readonly NAVIGATION_STRATEGY: "NAVIGATION_STRATEGY";
+};
 interface CardHistory<T extends CardRecord> {
     _id: PouchDB.Core.DocumentId;
     /**
@@ -140,4 +151,4 @@ interface QuestionRecord extends CardRecord, Evaluation {
     priorAttemps: number;
 }
 
-export { type CardRecord as C, DocType as D, type Field as F, GuestUsername as G, type QualifiedCardID as Q, type SkuilderCourseData as S, type TagStub as T, type Tag as a, type CardData as b, type CourseListData as c, type DisplayableData as d, type DataShapeData as e, type QuestionData as f, DocTypePrefixes as g, type CardHistory as h, type QuestionRecord as i, log as l };
+export { type CardHistory as C, DocType as D, type Field as F, GuestUsername as G, type QualifiedCardID as Q, type SkuilderCourseData as S, type TagStub as T, type Tag as a, DocTypePrefixes as b, type CardRecord as c, type CardData as d, type CourseListData as e, type DisplayableData as f, type DataShapeData as g, type QuestionData as h, type QuestionRecord as i, log as l };

package/dist/{userDB-DJ8HMw83.d.mts → userDB-C4yyAnpp.d.mts}

@@ -1,6 +1,6 @@
 import { CourseConfig, ClassroomConfig, CourseElo, Status, SkuilderCourseData as SkuilderCourseData$1, DataShape } from '@vue-skuilder/common';
 import { Moment } from 'moment';
-import { S as SkuilderCourseData, D as DocType, Q as QualifiedCardID, T as TagStub, a as Tag, h as CardHistory, C as CardRecord } from './types-legacy-B8ahaCbj.mjs';
+import { S as SkuilderCourseData, b as DocTypePrefixes, D as DocType, Q as QualifiedCardID, T as TagStub, a as Tag, C as CardHistory, c as CardRecord } from './types-legacy-6ettoclI.mjs';
 
 /**
  * Admin functionality
@@ -199,7 +199,7 @@ interface DataLayerResult {
  *
  */
 interface ContentNavigationStrategyData extends SkuilderCourseData {
-    id: string;
+    _id: `${typeof DocTypePrefixes[DocType.NAVIGATION_STRATEGY]}-${string}`;
     docType: DocType.NAVIGATION_STRATEGY;
     name: string;
     description: string;
@@ -530,4 +530,4 @@ interface ClassroomRegistrationDoc {
     registrations: ClassroomRegistration[];
 }
 
-export { type AdminDBInterface as A, type ClassroomRegistration as B, type CourseDBInterface as C, type DataLayerResult as D, type ClassroomRegistrationDoc as E, type UserConfig as F, type ActivityRecord as G, type CourseRegistration as H, type CourseRegistrationDoc as I, type DocumentUpdater as J, newInterval as K, type StudySessionNewItem as S, type TeacherClassroomDBInterface as T, type UserDBInterface as U, type UserDBReader as a, type CoursesDBInterface as b, type ClassroomDBInterface as c, type CourseInfo as d, type ContentNavigationStrategyData as e, type StudySessionReviewItem as f, type ScheduledCard as g, type AssignedContent as h, type StudyContentSource as i, type StudentClassroomDBInterface as j, type StudySessionItem as k, type StudySessionFailedItem as l, type StudySessionFailedNewItem as m, type StudySessionFailedReviewItem as n, isReview as o, type ContentSourceID as p, getStudySource as q, type AssignedTag as r, type AssignedCourse as s, type AssignedCard as t, type UserDBWriter as u, type UserDBAuthenticator as v, type UserCourseSettings as w, type UserCourseSetting as x, type UsrCrsDataInterface as y, type ClassroomRegistrationDesignation as z };
+export { type AdminDBInterface as A, type ClassroomRegistrationDesignation as B, type CourseDBInterface as C, type DataLayerResult as D, type ClassroomRegistration as E, type ClassroomRegistrationDoc as F, type UserConfig as G, type ActivityRecord as H, type CourseRegistration as I, type DocumentUpdater as J, newInterval as K, type StudySessionNewItem as S, type TeacherClassroomDBInterface as T, type UserDBInterface as U, type UserDBReader as a, type CoursesDBInterface as b, type ClassroomDBInterface as c, type CourseInfo as d, type ContentNavigationStrategyData as e, type StudySessionReviewItem as f, type ScheduledCard as g, type AssignedContent as h, type StudyContentSource as i, type StudentClassroomDBInterface as j, type StudySessionItem as k, type StudySessionFailedItem as l, type StudySessionFailedNewItem as m, type StudySessionFailedReviewItem as n, isReview as o, type ContentSourceID as p, getStudySource as q, type CourseRegistrationDoc as r, type AssignedTag as s, type AssignedCourse as t, type AssignedCard as u, type UserDBWriter as v, type UserDBAuthenticator as w, type UserCourseSettings as x, type UserCourseSetting as y, type UsrCrsDataInterface as z };

package/dist/{userDB-B7zTQ123.d.ts → userDB-CD6s6ZCp.d.ts}

@@ -1,6 +1,6 @@
 import { CourseConfig, ClassroomConfig, CourseElo, Status, SkuilderCourseData as SkuilderCourseData$1, DataShape } from '@vue-skuilder/common';
 import { Moment } from 'moment';
-import { S as SkuilderCourseData, D as DocType, Q as QualifiedCardID, T as TagStub, a as Tag, h as CardHistory, C as CardRecord } from './types-legacy-B8ahaCbj.js';
+import { S as SkuilderCourseData, b as DocTypePrefixes, D as DocType, Q as QualifiedCardID, T as TagStub, a as Tag, C as CardHistory, c as CardRecord } from './types-legacy-6ettoclI.js';
 
 /**
  * Admin functionality
@@ -199,7 +199,7 @@ interface DataLayerResult {
  *
  */
 interface ContentNavigationStrategyData extends SkuilderCourseData {
-    id: string;
+    _id: `${typeof DocTypePrefixes[DocType.NAVIGATION_STRATEGY]}-${string}`;
     docType: DocType.NAVIGATION_STRATEGY;
     name: string;
     description: string;
@@ -530,4 +530,4 @@ interface ClassroomRegistrationDoc {
     registrations: ClassroomRegistration[];
 }
 
-export { type AdminDBInterface as A, type ClassroomRegistration as B, type CourseDBInterface as C, type DataLayerResult as D, type ClassroomRegistrationDoc as E, type UserConfig as F, type ActivityRecord as G, type CourseRegistration as H, type CourseRegistrationDoc as I, type DocumentUpdater as J, newInterval as K, type StudySessionNewItem as S, type TeacherClassroomDBInterface as T, type UserDBInterface as U, type UserDBReader as a, type CoursesDBInterface as b, type ClassroomDBInterface as c, type CourseInfo as d, type ContentNavigationStrategyData as e, type StudySessionReviewItem as f, type ScheduledCard as g, type AssignedContent as h, type StudyContentSource as i, type StudentClassroomDBInterface as j, type StudySessionItem as k, type StudySessionFailedItem as l, type StudySessionFailedNewItem as m, type StudySessionFailedReviewItem as n, isReview as o, type ContentSourceID as p, getStudySource as q, type AssignedTag as r, type AssignedCourse as s, type AssignedCard as t, type UserDBWriter as u, type UserDBAuthenticator as v, type UserCourseSettings as w, type UserCourseSetting as x, type UsrCrsDataInterface as y, type ClassroomRegistrationDesignation as z };
+export { type AdminDBInterface as A, type ClassroomRegistrationDesignation as B, type CourseDBInterface as C, type DataLayerResult as D, type ClassroomRegistration as E, type ClassroomRegistrationDoc as F, type UserConfig as G, type ActivityRecord as H, type CourseRegistration as I, type DocumentUpdater as J, newInterval as K, type StudySessionNewItem as S, type TeacherClassroomDBInterface as T, type UserDBInterface as U, type UserDBReader as a, type CoursesDBInterface as b, type ClassroomDBInterface as c, type CourseInfo as d, type ContentNavigationStrategyData as e, type StudySessionReviewItem as f, type ScheduledCard as g, type AssignedContent as h, type StudyContentSource as i, type StudentClassroomDBInterface as j, type StudySessionItem as k, type StudySessionFailedItem as l, type StudySessionFailedNewItem as m, type StudySessionFailedReviewItem as n, isReview as o, type ContentSourceID as p, getStudySource as q, type CourseRegistrationDoc as r, type AssignedTag as s, type AssignedCourse as t, type AssignedCard as u, type UserDBWriter as v, type UserDBAuthenticator as w, type UserCourseSettings as x, type UserCourseSetting as y, type UsrCrsDataInterface as z };

package/dist/util/packer/index.d.mts

@@ -1,5 +1,5 @@
-export { A as AttachmentData, C as ChunkMetadata, D as DesignDocument, I as IndexMetadata, a as PackedCourseData, P as PackerConfig, S as StaticCourseManifest } from '../../types-Che4wTwA.mjs';
-export { C as CouchDBToStaticPacker } from '../../index-DZyxHCcf.mjs';
+export { A as AttachmentData, C as ChunkMetadata, D as DesignDocument, I as IndexMetadata, a as PackedCourseData, P as PackerConfig, S as StaticCourseManifest } from '../../types-Dbp5DaRR.mjs';
+export { C as CouchDBToStaticPacker } from '../../index-Bmll7Xse.mjs';
 import '@vue-skuilder/common';
-import '../../types-legacy-B8ahaCbj.mjs';
+import '../../types-legacy-6ettoclI.mjs';
 import 'moment';

package/dist/util/packer/index.d.ts

@@ -1,5 +1,5 @@
-export { A as AttachmentData, C as ChunkMetadata, D as DesignDocument, I as IndexMetadata, a as PackedCourseData, P as PackerConfig, S as StaticCourseManifest } from '../../types-DtoI27Xh.js';
-export { C as CouchDBToStaticPacker } from '../../index-CWY6yhkV.js';
+export { A as AttachmentData, C as ChunkMetadata, D as DesignDocument, I as IndexMetadata, a as PackedCourseData, P as PackerConfig, S as StaticCourseManifest } from '../../types-CewsN87z.js';
+export { C as CouchDBToStaticPacker } from '../../index-CD8BZz2k.js';
 import '@vue-skuilder/common';
-import '../../types-legacy-B8ahaCbj.js';
+import '../../types-legacy-6ettoclI.js';
 import 'moment';

package/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "0.1.11",
+  "version": "0.1.12",
   "description": "Database layer for vue-skuilder",
   "main": "dist/index.js",
   "module": "dist/index.mjs",
@@ -45,7 +45,7 @@
   },
   "dependencies": {
     "@nilock2/pouchdb-authentication": "^1.0.2",
-    "@vue-skuilder/common": "0.1.11",
+    "@vue-skuilder/common": "0.1.12",
     "cross-fetch": "^4.1.0",
     "moment": "^2.29.4",
     "pouchdb": "^9.0.0",
@@ -57,5 +57,5 @@
     "tsup": "^8.0.2",
     "typescript": "~5.7.2"
   },
-  "stableVersion": "0.1.11"
+  "stableVersion": "0.1.12"
 }

package/src/core/navigators/hardcodedOrder.ts

@@ -0,0 +1,64 @@
+import { CourseDBInterface, QualifiedCardID, StudySessionNewItem, StudySessionReviewItem, UserDBInterface } from '..';
+import { ContentNavigationStrategyData } from '../types/contentNavigationStrategy';
+import { ScheduledCard } from '../types/user';
+import { ContentNavigator } from './index';
+import { logger } from '../../util/logger';
+
+export default class HardcodedOrderNavigator extends ContentNavigator {
+  private orderedCardIds: string[] = [];
+  private user: UserDBInterface;
+  private course: CourseDBInterface;
+
+  constructor(
+    user: UserDBInterface,
+    course: CourseDBInterface,
+    strategyData: ContentNavigationStrategyData
+  ) {
+    super();
+    this.user = user;
+    this.course = course;
+
+    if (strategyData.serializedData) {
+      try {
+        this.orderedCardIds = JSON.parse(strategyData.serializedData);
+      } catch (e) {
+        logger.error('Failed to parse serializedData for HardcodedOrderNavigator', e);
+      }
+    }
+  }
+
+  async getPendingReviews(): Promise<(StudySessionReviewItem & ScheduledCard)[]> {
+    const reviews = await this.user.getPendingReviews(this.course.getCourseID());
+    return reviews.map((r) => {
+      return {
+        ...r,
+        contentSourceType: 'course',
+        contentSourceID: this.course.getCourseID(),
+        cardID: r.cardId,
+        courseID: r.courseId,
+        reviewID: r._id,
+        status: 'review',
+      };
+    });
+  }
+
+  async getNewCards(limit: number = 99): Promise<StudySessionNewItem[]> {
+    const activeCardIds = (await this.user.getActiveCards()).map((c: QualifiedCardID) => c.cardID);
+
+    const newCardIds = this.orderedCardIds.filter(
+      (cardId) => !activeCardIds.includes(cardId)
+    );
+
+    const cardsToReturn = newCardIds.slice(0, limit);
+
+    return cardsToReturn.map((cardId) => {
+      return {
+        cardID: cardId,
+        courseID: this.course.getCourseID(),
+        contentSourceType: 'course',
+        contentSourceID: this.course.getCourseID(),
+        status: 'new',
+      };
+    });
+  }
+}

package/src/core/navigators/index.ts

@@ -11,6 +11,7 @@ import { logger } from '../../util/logger';
 
 export enum Navigators {
   ELO = 'elo',
+  HARDCODED = 'hardcodedOrder',
 }
 
 /**

package/src/core/types/contentNavigationStrategy.ts

@@ -1,10 +1,11 @@
 import { DocType, SkuilderCourseData } from './types-legacy';
+import type { DocTypePrefixes } from './types-legacy';
 
 /**
  *
  */
 export interface ContentNavigationStrategyData extends SkuilderCourseData {
-  id: string;
+  _id: `${typeof DocTypePrefixes[DocType.NAVIGATION_STRATEGY]}-${string}`;
   docType: DocType.NAVIGATION_STRATEGY;
   name: string;
   description: string;

package/src/core/types/types-legacy.ts

@@ -91,7 +91,7 @@ export interface QuestionData extends SkuilderCourseData {
   dataShapeList: PouchDB.Core.DocumentId[];
 }
 
-export const DocTypePrefixes: Record<string, string> = {
+export const DocTypePrefixes = {
   [DocType.CARD]: 'c',
   [DocType.DISPLAYABLE_DATA]: 'dd',
   [DocType.TAG]: 'TAG',
@@ -103,7 +103,7 @@ export const DocTypePrefixes: Record<string, string> = {
   [DocType.VIEW]: 'VIEW',
   [DocType.PEDAGOGY]: 'PEDAGOGY',
   [DocType.NAVIGATION_STRATEGY]: 'NAVIGATION_STRATEGY',
-};
+} as const;
 
 export interface CardHistory<T extends CardRecord> {
   _id: PouchDB.Core.DocumentId;

package/src/impl/common/BaseUserDB.ts

@@ -761,17 +761,21 @@ Currently logged-in as ${this._username}.`
     } catch (e) {
       const reason = e as PouchError;
       if (reason.status === 404) {
-        const initCardHistory: CardHistory<T> = {
-          _id: cardHistoryID,
-          cardID: record.cardID,
-          courseID: record.courseID,
-          records: [record],
-          lapses: 0,
-          streak: 0,
-          bestInterval: 0,
-        };
-        const putResult = await this.writeDB.put<CardHistory<T>>(initCardHistory);
-        return { ...initCardHistory, _rev: putResult.rev };
+        try {
+          const initCardHistory: CardHistory<T> = {
+            _id: cardHistoryID,
+            cardID: record.cardID,
+            courseID: record.courseID,
+            records: [record],
+            lapses: 0,
+            streak: 0,
+            bestInterval: 0,
+          };
+          const putResult = await this.writeDB.put<CardHistory<T>>(initCardHistory);
+          return { ...initCardHistory, _rev: putResult.rev };
+        } catch (creationError) {
+          throw new Error(`Failed to create CardHistory for ${cardHistoryID}. Reason: ${creationError}`);
+        }
       } else {
         throw new Error(`putCardRecord failed because of:
   name:${reason.name}

package/src/impl/couch/courseDB.ts

@@ -25,6 +25,7 @@ import {
   SkuilderCourseData,
   Tag,
   TagStub,
+  DocTypePrefixes,
 } from '../../core/types/types-legacy';
 import { logger } from '../../util/logger';
 import { GET_CACHED } from './clientCache';
@@ -224,7 +225,29 @@ export class CourseDB implements StudyContentSource, CourseDBInterface {
     if (!doc.docType || !(doc.docType === DocType.CARD)) {
       throw new Error(`failed to remove ${id} from course ${this.id}. id does not point to a card`);
     }
-    // TODO: remove card from tags lists (getTagsByCards)
+    
+    // Remove card from all associated tags before deleting the card
+    try {
+      const appliedTags = await this.getAppliedTags(id);
+      const results = await Promise.allSettled(
+        appliedTags.rows.map(async (tagRow) => {
+          const tagId = tagRow.id;
+          await this.removeTagFromCard(id, tagId);
+        })
+      );
+      
+      // Log any individual tag cleanup failures
+      results.forEach((result, index) => {
+        if (result.status === 'rejected') {
+          const tagId = appliedTags.rows[index].id;
+          logger.error(`Failed to remove card ${id} from tag ${tagId}: ${result.reason}`);
+        }
+      });
+    } catch (error) {
+      logger.error(`Error removing card ${id} from tags: ${error}`);
+      // Continue with card deletion even if tag cleanup fails
+    }
+    
     return this.db.remove(doc);
   }
 
@@ -456,40 +479,38 @@ above:\n${above.rows.map((r) => `\t${r.id}-${r.key}\n`)}`;
 
   getNavigationStrategy(id: string): Promise<ContentNavigationStrategyData> {
     logger.debug(`[courseDB] Getting navigation strategy: ${id}`);
-    // For now, just return the ELO strategy regardless of the ID
-    const strategy: ContentNavigationStrategyData = {
-      id: 'ELO',
-      docType: DocType.NAVIGATION_STRATEGY,
-      name: 'ELO',
-      description: 'ELO-based navigation strategy for ordering content by difficulty',
-      implementingClass: Navigators.ELO,
-      course: this.id,
-      serializedData: '', // serde is a noop for ELO navigator.
-    };
-    return Promise.resolve(strategy);
-  }
 
-  getAllNavigationStrategies(): Promise<ContentNavigationStrategyData[]> {
-    logger.debug('[courseDB] Returning hard-coded navigation strategies');
-    const strategies: ContentNavigationStrategyData[] = [
-      {
-        id: 'ELO',
+    if (id == '') {
+      const strategy: ContentNavigationStrategyData = {
+        _id: 'NAVIGATION_STRATEGY-ELO',
         docType: DocType.NAVIGATION_STRATEGY,
         name: 'ELO',
         description: 'ELO-based navigation strategy for ordering content by difficulty',
         implementingClass: Navigators.ELO,
         course: this.id,
         serializedData: '', // serde is a noop for ELO navigator.
-      },
-    ];
-    return Promise.resolve(strategies);
+      };
+      return Promise.resolve(strategy);
+    } else {
+      return this.db.get(id);
+    }
   }
 
-  addNavigationStrategy(data: ContentNavigationStrategyData): Promise<void> {
-    logger.debug(`[courseDB] Adding navigation strategy: ${data.id}`);
-    // For now, just log the data and return success
-    logger.debug(JSON.stringify(data));
-    return Promise.resolve();
+  async getAllNavigationStrategies(): Promise<ContentNavigationStrategyData[]> {
+    const prefix = DocTypePrefixes[DocType.NAVIGATION_STRATEGY];
+    const result = await this.db.allDocs<ContentNavigationStrategyData>({
+      startkey: prefix,
+      endkey: `${prefix}\ufff0`,
+      include_docs: true,
+    });
+    return result.rows.map((row) => row.doc!);
+  }
+
+  async addNavigationStrategy(data: ContentNavigationStrategyData): Promise<void> {
+    logger.debug(`[courseDB] Adding navigation strategy: ${data._id}`);
+    // // For now, just log the data and return success
+    // logger.debug(JSON.stringify(data));
+    return this.db.put(data).then(() => {});
   }
   updateNavigationStrategy(id: string, data: ContentNavigationStrategyData): Promise<void> {
     logger.debug(`[courseDB] Updating navigation strategy: ${id}`);
@@ -499,9 +520,35 @@ above:\n${above.rows.map((r) => `\t${r.id}-${r.key}\n`)}`;
   }
 
   async surfaceNavigationStrategy(): Promise<ContentNavigationStrategyData> {
+    try {
+      const config = await this.getCourseConfig();
+      // @ts-expect-error tmp: defaultNavigationStrategyId property does not yet exist
+      if (config.defaultNavigationStrategyId) {
+        try {
+          // @ts-expect-error tmp: defaultNavigationStrategyId property does not yet exist
+          const strategy = await this.getNavigationStrategy(config.defaultNavigationStrategyId);
+          if (strategy) {
+            logger.debug(`Surfacing strategy ${strategy.name} from course config`);
+            return strategy;
+          }
+        } catch (e) {
+          logger.warn(
+            // @ts-expect-error tmp: defaultNavigationStrategyId property does not yet exist
+            `Failed to load strategy '${config.defaultNavigationStrategyId}' specified in course config. Falling back to ELO.`,
+            e
+          );
+        }
+      }
+    } catch (e) {
+      logger.warn(
+        'Could not retrieve course config to determine navigation strategy. Falling back to ELO.',
+        e
+      );
+    }
+
     logger.warn(`Returning hard-coded default ELO navigator`);
     const ret: ContentNavigationStrategyData = {
-      id: 'ELO',
+      _id: 'NAVIGATION_STRATEGY-ELO',
       docType: DocType.NAVIGATION_STRATEGY,
       name: 'ELO',
       description: 'ELO-based navigation strategy',

package/src/impl/couch/updateQueue.ts

@@ -44,9 +44,10 @@ export default class UpdateQueue extends Loggable {
   ): Promise<T & PouchDB.Core.GetMeta & PouchDB.Core.RevisionIdMeta> {
     logger.debug(`Applying updates on doc: ${id}`);
     if (this.inprogressUpdates[id]) {
-      // console.log(`Updates in progress...`);
-      await this.readDB.info(); // stall for a round trip
-      // console.log(`Retrying...`);
+      // Poll instead of recursing to avoid infinite recursion
+      while (this.inprogressUpdates[id]) {
+        await new Promise(resolve => setTimeout(resolve, Math.random() * 50));
+      }
       return this.applyUpdates<T>(id);
     } else {
       if (this.pendingUpdates[id] && this.pendingUpdates[id].length > 0) {
@@ -94,6 +95,10 @@ export default class UpdateQueue extends Loggable {
               logger.warn(`Conflict on update for doc ${id}, retry #${i + 1}`);
               await new Promise((res) => setTimeout(res, 50 * Math.random()));
               // continue to next iteration of the loop
+            } else if (e.name === 'not_found' && i === 0) {
+              // Document not present - throw to caller for initialization
+              logger.warn(`Update failed for ${id} - does not exist. Throwing to caller.`);
+              throw e; // Let caller handle
             } else {
               // Max retries reached or a non-conflict error
               delete this.inprogressUpdates[id];

package/src/impl/static/StaticDataLayerProvider.ts

@@ -1,3 +1,4 @@
+
 // packages/db/src/impl/static/StaticDataLayerProvider.ts
 
 import {
@@ -17,39 +18,78 @@ import { StaticCoursesDB } from './coursesDB';
 import { BaseUser } from '../common';
 import { NoOpSyncStrategy } from './NoOpSyncStrategy';
 
+
+interface SkuilderManifest {
+  name?: string;
+  version?: string;
+  description?: string;
+  dependencies?: Record<string, string>;
+}
+
 interface StaticDataLayerConfig {
-  staticContentPath: string;
   localStoragePrefix?: string;
-  manifests: Record<string, StaticCourseManifest>; // courseId -> manifest
+  rootManifest: SkuilderManifest; // The parsed root skuilder.json object
+  rootManifestUrl: string; // The absolute URL where the root manifest was found
 }
 
 export class StaticDataLayerProvider implements DataLayerProvider {
   private config: StaticDataLayerConfig;
   private initialized: boolean = false;
   private courseUnpackers: Map<string, StaticDataUnpacker> = new Map();
+  private manifests: Record<string, StaticCourseManifest> = {};
 
   constructor(config: Partial<StaticDataLayerConfig>) {
     this.config = {
-      staticContentPath: config.staticContentPath || '/static-courses',
       localStoragePrefix: config.localStoragePrefix || 'skuilder-static',
-      manifests: config.manifests || {},
+      rootManifest: config.rootManifest || { dependencies: {} },
+      rootManifestUrl: config.rootManifestUrl || '/',
     };
   }
 
+  private async resolveCourseDependencies(): Promise<void> {
+    logger.info('[StaticDataLayerProvider] Starting course dependency resolution...');
+    const rootManifest = this.config.rootManifest;
+
+    for (const [courseName, courseUrl] of Object.entries(rootManifest.dependencies || {})) {
+      try {
+        logger.debug(`[StaticDataLayerProvider] Resolving dependency: ${courseName} from ${courseUrl}`);
+        
+        const courseManifestUrl = new URL(courseUrl as string, this.config.rootManifestUrl).href;
+        const courseJsonResponse = await fetch(courseManifestUrl);
+        if (!courseJsonResponse.ok) {
+          throw new Error(`Failed to fetch course manifest for ${courseName}`);
+        }
+        const courseJson = await courseJsonResponse.json();
+
+        if (courseJson.content && courseJson.content.manifest) {
+          const baseUrl = new URL('.', courseManifestUrl).href;
+          const finalManifestUrl = new URL(courseJson.content.manifest, courseManifestUrl).href;
+
+          const finalManifestResponse = await fetch(finalManifestUrl);
+          if (!finalManifestResponse.ok) {
+            throw new Error(`Failed to fetch final content manifest for ${courseName} at ${finalManifestUrl}`);
+          }
+          const finalManifest = await finalManifestResponse.json();
+          
+          this.manifests[courseName] = finalManifest;
+          const unpacker = new StaticDataUnpacker(finalManifest, baseUrl);
+          this.courseUnpackers.set(courseName, unpacker);
+
+          logger.info(`[StaticDataLayerProvider] Successfully resolved and prepared course: ${courseName}`);
+        }
+      } catch (e) {
+        logger.error(`[StaticDataLayerProvider] Failed to resolve dependency ${courseName}:`, e);
+        // Continue to next dependency
+      }
+    }
+    logger.info('[StaticDataLayerProvider] Course dependency resolution complete.');
+  }
+
   async initialize(): Promise<void> {
     if (this.initialized) return;
 
     logger.info('Initializing static data layer provider');
-
-    // Load manifests for all courses
-    for (const [courseId, manifest] of Object.entries(this.config.manifests)) {
-      const unpacker = new StaticDataUnpacker(
-        manifest,
-        `${this.config.staticContentPath}/${courseId}`
-      );
-      this.courseUnpackers.set(courseId, unpacker);
-    }
-
+    await this.resolveCourseDependencies();
     this.initialized = true;
   }
 
@@ -67,14 +107,14 @@ export class StaticDataLayerProvider implements DataLayerProvider {
   getCourseDB(courseId: string): CourseDBInterface {
     const unpacker = this.courseUnpackers.get(courseId);
     if (!unpacker) {
-      throw new Error(`Course ${courseId} not found in static data`);
+      throw new Error(`Course ${courseId} not found or failed to initialize in static data layer.`);
     }
-    const manifest = this.config.manifests[courseId];
+    const manifest = this.manifests[courseId];
     return new StaticCourseDB(courseId, unpacker, this.getUserDB(), manifest);
   }
 
   getCoursesDB(): CoursesDBInterface {
-    return new StaticCoursesDB(this.config.manifests);
+    return new StaticCoursesDB(this.manifests);
   }
 
   async getClassroomDB(

package/src/impl/static/courseDB.ts

@@ -132,17 +132,22 @@ export class StaticCourseDB implements CourseDBInterface {
     return { ok: true, id: cardId, rev: '1-static' };
   }
 
-  async getNewCards(limit?: number): Promise<StudySessionNewItem[]> {
-    // Simplified implementation - would need proper navigation strategy
-    const cardIds = await this.unpacker.queryByElo(1000, limit || 10);
-    return cardIds.map((cardId) => ({
-      status: 'new' as const,
-      qualifiedID: `${this.courseId}-${cardId}`,
-      cardID: cardId,
-      contentSourceType: 'course' as const,
-      contentSourceID: this.courseId,
-      courseID: this.courseId,
-    }));
+  async getNewCards(limit: number = 99): Promise<StudySessionNewItem[]> {
+    const activeCards = await this.userDB.getActiveCards();
+    return (
+      await this.getCardsCenteredAtELO({ limit: limit, elo: 'user' }, (c: QualifiedCardID) => {
+        if (activeCards.some((ac) => c.cardID === ac.cardID)) {
+          return false;
+        } else {
+          return true;
+        }
+      })
+    ).map((c) => {
+      return {
+        ...c,
+        status: 'new',
+      };
+    });
   }
 
   async getCardsCenteredAtELO(
@@ -364,7 +369,7 @@ export class StaticCourseDB implements CourseDBInterface {
   // Navigation Strategy Manager implementation
   async getNavigationStrategy(_id: string): Promise<ContentNavigationStrategyData> {
     return {
-      id: 'ELO',
+      _id: 'NAVIGATION_STRATEGY-ELO',
       docType: DocType.NAVIGATION_STRATEGY,
       name: 'ELO',
       description: 'ELO-based navigation strategy',