@vue-skuilder/db 0.1.33 → 0.1.34

package/package.json

@@ -4,7 +4,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "0.1.33",
+  "version": "0.1.34",
   "description": "Database layer for vue-skuilder",
   "main": "dist/index.js",
   "module": "dist/index.mjs",
@@ -48,7 +48,7 @@
   },
   "dependencies": {
     "@nilock2/pouchdb-authentication": "^1.0.2",
-    "@vue-skuilder/common": "0.1.33",
+    "@vue-skuilder/common": "0.1.34",
     "cross-fetch": "^4.1.0",
     "moment": "^2.29.4",
     "pouchdb": "^9.0.0",
@@ -62,5 +62,5 @@
     "vite": "^8.0.0",
     "vitest": "^4.1.0"
   },
-  "stableVersion": "0.1.33"
+  "stableVersion": "0.1.34"
 }

package/src/core/navigators/generators/srs.ts

@@ -131,7 +131,29 @@ export default class SRSNavigator extends ContentNavigator implements CardGenera
     const now = moment.utc();
 
     // Filter to only cards that are actually due
-    const dueReviews = reviews.filter((r) => now.isAfter(moment.utc(r.reviewTime)));
+    let dueReviews = reviews.filter((r) => now.isAfter(moment.utc(r.reviewTime)));
+
+    // Remove scheduled reviews for cards tagged srs:skip (e.g. intro cards).
+    // These were scheduled before the tag convention existed — clean them up.
+    if (dueReviews.length > 0) {
+      const dueCardIds = [...new Set(dueReviews.map((r) => r.cardId))];
+      const tagsByCard = await this.course!.getAppliedTagsBatch(dueCardIds);
+      const skippedReviewIds: string[] = [];
+      dueReviews = dueReviews.filter((r) => {
+        const tags = tagsByCard.get(r.cardId) ?? [];
+        if (tags.includes('srs:skip')) {
+          skippedReviewIds.push(r._id);
+          return false;
+        }
+        return true;
+      });
+      if (skippedReviewIds.length > 0) {
+        logger.info(`[SRS] Removing ${skippedReviewIds.length} scheduled reviews for srs:skip cards`);
+        for (const id of skippedReviewIds) {
+          void this.user!.removeScheduledCardReview(id);
+        }
+      }
+    }
 
     // Compute backlog pressure - applies globally to all reviews
     const backlogPressure = this.computeBacklogPressure(dueReviews.length);

package/src/impl/common/BaseUserDB.ts

@@ -889,18 +889,21 @@ Currently logged-in as ${this._username}.`
    * @param course_id optional specification of individual course
    */
   async getSeenCards(course_id?: string) {
-    let prefix = DocTypePrefixes[DocType.CARDRECORD];
+    // Doc IDs follow the pattern: cardH-{courseId}-{cardId}
+    // (see getCardHistoryID in core/util)
+    const basePrefix = DocTypePrefixes[DocType.CARDRECORD];
+    let filterPrefix = basePrefix;
     if (course_id) {
-      prefix += course_id;
+      filterPrefix += `-${course_id}-`;
     }
-    const docs = await filterAllDocsByPrefix(this.localDB, prefix, {
+    const docs = await filterAllDocsByPrefix(this.localDB, filterPrefix, {
       include_docs: false,
     });
-    // const docs = await this.localDB.allDocs({});
     const ret: PouchDB.Core.DocumentId[] = [];
     docs.rows.forEach((row) => {
-      if (row.id.startsWith(DocTypePrefixes[DocType.CARDRECORD])) {
-        ret.push(row.id.substr(DocTypePrefixes[DocType.CARDRECORD].length));
+      if (row.id.startsWith(filterPrefix)) {
+        // Strip the full prefix to return bare cardId
+        ret.push(row.id.substr(filterPrefix.length));
       }
     });
     return ret;

package/src/study/SessionController.ts

@@ -124,6 +124,16 @@ export class SessionController<TView = unknown> extends Loggable {
    */
   private _defaultBatchLimit: number = 20;
 
+  /**
+   * Maximum number of reviews enqueued at session start. Reviews live
+   * outside the replan flow — the queue drains via consumption and is
+   * not refilled mid-session. The session timer caps total review
+   * exposure, so overfilling here is intentional. Default is generous
+   * to accommodate Anki-style power users with hundreds of due reviews;
+   * apps targeting nimbler sessions should override via constructor.
+   */
+  private _initialReviewCap: number = 200;
+
   private sources: StudyContentSource[];
   // dataLayer and getViewComponent now injected into CardHydrationService
   private _sessionRecord: StudySessionRecord[] = [];
@@ -208,6 +218,8 @@ export class SessionController<TView = unknown> extends Loggable {
    * @param options.defaultBatchLimit - Default pipeline batch size (default: 20).
    *   Smaller values for newer users cause more frequent replans, keeping plans
    *   aligned with rapidly-changing user state.
+   * @param options.initialReviewCap - Max reviews loaded at session start (default: 200).
+   *   Applied only on initial planning; replans do not refill the review queue.
    */
   constructor(
     sources: StudyContentSource[],
@@ -215,7 +227,7 @@ export class SessionController<TView = unknown> extends Loggable {
     dataLayer: DataLayerProvider,
     getViewComponent: (viewId: string) => TView,
     mixer?: SourceMixer,
-    options?: { defaultBatchLimit?: number }
+    options?: { defaultBatchLimit?: number; initialReviewCap?: number }
   ) {
     super();
 
@@ -242,11 +254,15 @@ export class SessionController<TView = unknown> extends Loggable {
     if (options?.defaultBatchLimit !== undefined) {
       this._defaultBatchLimit = options.defaultBatchLimit;
     }
+    if (options?.initialReviewCap !== undefined) {
+      this._initialReviewCap = options.initialReviewCap;
+    }
 
     this.log(`Session constructed:
     startTime: ${this.startTime}
     endTime: ${this.endTime}
-    defaultBatchLimit: ${this._defaultBatchLimit}`);
+    defaultBatchLimit: ${this._defaultBatchLimit}
+    initialReviewCap: ${this._initialReviewCap}`);
   }
 
   private tick() {
@@ -354,18 +370,21 @@ export class SessionController<TView = unknown> extends Loggable {
       return this._replanPromise;
     }
 
-    // Auto-exclude the currently-displayed card so the replan doesn't
-    // surface it again (avoids showing the same card twice in a row).
+    // Exclude all cards already presented this session. The pipeline may
+    // not yet see their encounter records (async writes), so without this
+    // they can re-enter newQ via replaceAll and cause duplicates.
+    if (!opts.hints) opts.hints = {};
+    const hints = opts.hints;
+    const excludeSet = new Set(hints.excludeCards ?? []);
+
     if (this._currentCard?.item.cardID) {
-      const currentId = this._currentCard.item.cardID;
-      if (!opts.hints) opts.hints = {};
-      const hints = opts.hints;
-      const excludeCards = hints.excludeCards ?? [];
-      if (!excludeCards.includes(currentId)) {
-        excludeCards.push(currentId);
-      }
-      hints.excludeCards = excludeCards;
+      excludeSet.add(this._currentCard.item.cardID);
     }
+    for (const rec of this._sessionRecord) {
+      excludeSet.add(rec.card.card_id);
+    }
+
+    hints.excludeCards = [...excludeSet];
 
     // Forward hints to all sources (CourseDB stashes them, Pipeline consumes them)
     if (opts.hints) {
@@ -583,7 +602,11 @@ export class SessionController<TView = unknown> extends Loggable {
   }): Promise<number> {
     const replan = options?.replan ?? false;
     const additive = options?.additive ?? false;
-    const limit = options?.limit ?? this._defaultBatchLimit;
+    const newLimit = options?.limit ?? this._defaultBatchLimit;
+    // Initial planning inflates the per-source budget so reviews can fill up
+    // to _initialReviewCap independently of the new-card budget. Replans
+    // never touch reviewQ, so the inflation is unnecessary there.
+    const fetchLimit = replan ? newLimit : newLimit + this._initialReviewCap;
 
     // Collect batches from each source
     const batches: SourceBatch[] = [];
@@ -592,7 +615,7 @@ export class SessionController<TView = unknown> extends Loggable {
       const source = this.sources[i];
       try {
         // Fetch weighted cards for mixing
-        const weighted = (await source.getWeightedCards!(limit)).cards;
+        const weighted = (await source.getWeightedCards!(fetchLimit)).cards;
 
         batches.push({
           sourceIndex: i,
@@ -621,7 +644,7 @@ export class SessionController<TView = unknown> extends Loggable {
     }
 
     // Mix weighted cards across sources using configured strategy
-    const mixedWeighted = this.mixer.mix(batches, limit * this.sources.length);
+    const mixedWeighted = this.mixer.mix(batches, fetchLimit * this.sources.length);
 
     // Capture mixer run for debugging - fetch course names
     const sourceIds = batches.map((b) => {
@@ -643,20 +666,27 @@ export class SessionController<TView = unknown> extends Loggable {
     );
     const sourceNames = sourceIds.map((id) => this.courseNameCache.get(id));
     const quotaPerSource =
-      this.mixer instanceof QuotaRoundRobinMixer ? Math.ceil((limit * this.sources.length) / batches.length) : undefined;
+      this.mixer instanceof QuotaRoundRobinMixer ? Math.ceil((fetchLimit * this.sources.length) / batches.length) : undefined;
     captureMixerRun(
       this.mixer.constructor.name,
       batches,
       sourceIds,
       sourceNames,
-      limit * this.sources.length,
+      fetchLimit * this.sources.length,
       quotaPerSource,
       mixedWeighted
     );
 
-    // Split mixed results by card origin
-    const reviewWeighted = mixedWeighted.filter((w) => getCardOrigin(w) === 'review');
-    const newWeighted = mixedWeighted.filter((w) => getCardOrigin(w) === 'new');
+    // Split mixed results by card origin, then apply per-origin caps. The
+    // pre-mixer fetch is inflated to fit both budgets; trimming here keeps
+    // newQ at the nimble batch size while letting reviewQ overfill up to
+    // _initialReviewCap (replan path discards reviewWeighted entirely).
+    const reviewWeighted = mixedWeighted
+      .filter((w) => getCardOrigin(w) === 'review')
+      .slice(0, this._initialReviewCap);
+    const newWeighted = mixedWeighted
+      .filter((w) => getCardOrigin(w) === 'new')
+      .slice(0, newLimit);
 
     logger.debug(`[reviews] got ${reviewWeighted.length} reviews from mixer`);
 

package/src/study/services/ResponseProcessor.ts

@@ -173,7 +173,11 @@ export class ResponseProcessor {
     // Only schedule and update ELO for first-time attempts
     if (cardRecord.priorAttemps === 0) {
       // Schedule the card for future review based on performance (async, non-blocking)
-      void this.srsService.scheduleReview(history, studySessionItem);
+      // Cards tagged srs:skip are one-time presentations (e.g. intro cards) — no review scheduling
+      const skipSrs = currentCard.card.tags.includes('srs:skip');
+      if (!skipSrs) {
+        void this.srsService.scheduleReview(history, studySessionItem);
+      }
 
       // Parse performance (may be numeric or structured)
       const { globalScore, taggedPerformance } = this.parsePerformance(cardRecord.performance);