@vue-skuilder/db 0.2.1 → 0.2.3

package/dist/{dataLayerProvider-BEqB8VBR.d.cts → dataLayerProvider-CiA2Rr0v.d.cts}

@@ -1,4 +1,4 @@
-import { U as UserDBInterface, a as UserDBReader, C as CourseDBInterface, b as CoursesDBInterface, c as ClassroomDBInterface, A as AdminDBInterface } from './contentSource-BMlMwSiG.cjs';
+import { U as UserDBInterface, a as UserDBReader, C as CourseDBInterface, b as CoursesDBInterface, c as ClassroomDBInterface, A as AdminDBInterface } from './contentSource-kI9_jwTu.cjs';
 
 /**
  * Main factory interface for data access

package/dist/{dataLayerProvider-DObSXjnf.d.ts → dataLayerProvider-DrBqOUa3.d.ts}

@@ -1,4 +1,4 @@
-import { U as UserDBInterface, a as UserDBReader, C as CourseDBInterface, b as CoursesDBInterface, c as ClassroomDBInterface, A as AdminDBInterface } from './contentSource-Ht3N2f-y.js';
+import { U as UserDBInterface, a as UserDBReader, C as CourseDBInterface, b as CoursesDBInterface, c as ClassroomDBInterface, A as AdminDBInterface } from './contentSource-Cplhv3bJ.js';
 
 /**
  * Main factory interface for data access

package/dist/impl/couch/index.d.cts

@@ -1,7 +1,7 @@
-import { T as TagStub, a as Tag, S as SkuilderCourseData, Q as QualifiedCardID } from '../../types-legacy-JXDxinpU.cjs';
+import { T as TagStub, a as Tag, S as SkuilderCourseData, Q as QualifiedCardID } from '../../types-legacy-4tlwHnXo.cjs';
 import { Moment } from 'moment';
-import { A as AdminDBInterface, g as AssignedContent, h as StudyContentSource, i as StudentClassroomDBInterface, U as UserDBInterface, G as GeneratorResult, T as TeacherClassroomDBInterface, b as CoursesDBInterface, C as CourseDBInterface, d as CourseInfo, D as DataLayerResult, e as ContentNavigationStrategyData, f as ContentNavigator, R as ReplanHints, S as StudySessionItem, j as ScheduledCard } from '../../contentSource-BMlMwSiG.cjs';
-export { q as ContentSourceID, k as StudySessionFailedItem, l as StudySessionFailedNewItem, m as StudySessionFailedReviewItem, n as StudySessionNewItem, o as StudySessionReviewItem, r as getStudySource, p as isReview } from '../../contentSource-BMlMwSiG.cjs';
+import { A as AdminDBInterface, g as AssignedContent, h as StudyContentSource, i as StudentClassroomDBInterface, U as UserDBInterface, G as GeneratorResult, T as TeacherClassroomDBInterface, b as CoursesDBInterface, C as CourseDBInterface, d as CourseInfo, D as DataLayerResult, e as ContentNavigationStrategyData, f as ContentNavigator, R as ReplanHints, S as StudySessionItem, j as ScheduledCard } from '../../contentSource-kI9_jwTu.cjs';
+export { q as ContentSourceID, k as StudySessionFailedItem, l as StudySessionFailedNewItem, m as StudySessionFailedReviewItem, n as StudySessionNewItem, o as StudySessionReviewItem, r as getStudySource, p as isReview } from '../../contentSource-kI9_jwTu.cjs';
 import * as _vue_skuilder_common from '@vue-skuilder/common';
 import { ClassroomConfig, DataShape, CourseElo, CourseConfig as CourseConfig$1 } from '@vue-skuilder/common';
 import { S as SyncStrategy, A as AccountCreationResult, a as AuthenticationResult } from '../../SyncStrategy-CyATpyLQ.cjs';
@@ -279,8 +279,40 @@ declare class CourseDB implements CourseDBInterface {
      * @returns Cards sorted by score descending
      */
     private _pendingHints;
+    /**
+     * Session-scoped cache of the broad ELO-neighbor pool used by
+     * getCardsCenteredAtELO. The `elo` view query re-indexes on first touch per
+     * call (PouchDB 9 ignores `stale`), so without this each plan/replan pays
+     * ~1.5-2s. The pool is fetched once and re-ranked against the live (roaming)
+     * ELO in memory on subsequent calls.
+     */
+    private _eloPoolCache;
+    private readonly _eloPoolTtlMs;
+    /**
+     * Cached assembled navigator (Pipeline). createNavigator() reads strategy
+     * docs and builds a fresh Pipeline every call — whose internal `_tagCache`
+     * and `_cachedOrchestration` are designed to make replans cheap but never
+     * survive, because the instance is discarded each run. Caching it lets those
+     * caches persist across plan/replan within a session (SessionController holds
+     * one CourseDB instance for the session's lifetime). Rebuilt on user change,
+     * TTL expiry, or explicit invalidation after a strategy-doc write.
+     */
+    private _cachedNavigator;
+    private readonly _navigatorTtlMs;
     setEphemeralHints(hints: ReplanHints): void;
     getWeightedCards(limit: number): Promise<GeneratorResult>;
+    /**
+     * Return the assembled navigator, reusing the cached instance when possible.
+     * Reuse preserves the Pipeline's per-session caches (tags, orchestration
+     * context) across replans, which is the dominant per-replan cost once the
+     * ELO-pool cost is removed. Rebuilds on user change or TTL expiry.
+     */
+    private _getCachedNavigator;
+    /**
+     * Drop the cached navigator so the next getWeightedCards() rebuilds it.
+     * Call after mutating this course's navigation strategy documents.
+     */
+    invalidateNavigatorCache(): void;
     getCardsCenteredAtELO(options?: {
         limit: number;
         elo: 'user' | 'random' | number;

package/dist/impl/couch/index.d.ts

@@ -1,7 +1,7 @@
-import { T as TagStub, a as Tag, S as SkuilderCourseData, Q as QualifiedCardID } from '../../types-legacy-JXDxinpU.js';
+import { T as TagStub, a as Tag, S as SkuilderCourseData, Q as QualifiedCardID } from '../../types-legacy-4tlwHnXo.js';
 import { Moment } from 'moment';
-import { A as AdminDBInterface, g as AssignedContent, h as StudyContentSource, i as StudentClassroomDBInterface, U as UserDBInterface, G as GeneratorResult, T as TeacherClassroomDBInterface, b as CoursesDBInterface, C as CourseDBInterface, d as CourseInfo, D as DataLayerResult, e as ContentNavigationStrategyData, f as ContentNavigator, R as ReplanHints, S as StudySessionItem, j as ScheduledCard } from '../../contentSource-Ht3N2f-y.js';
-export { q as ContentSourceID, k as StudySessionFailedItem, l as StudySessionFailedNewItem, m as StudySessionFailedReviewItem, n as StudySessionNewItem, o as StudySessionReviewItem, r as getStudySource, p as isReview } from '../../contentSource-Ht3N2f-y.js';
+import { A as AdminDBInterface, g as AssignedContent, h as StudyContentSource, i as StudentClassroomDBInterface, U as UserDBInterface, G as GeneratorResult, T as TeacherClassroomDBInterface, b as CoursesDBInterface, C as CourseDBInterface, d as CourseInfo, D as DataLayerResult, e as ContentNavigationStrategyData, f as ContentNavigator, R as ReplanHints, S as StudySessionItem, j as ScheduledCard } from '../../contentSource-Cplhv3bJ.js';
+export { q as ContentSourceID, k as StudySessionFailedItem, l as StudySessionFailedNewItem, m as StudySessionFailedReviewItem, n as StudySessionNewItem, o as StudySessionReviewItem, r as getStudySource, p as isReview } from '../../contentSource-Cplhv3bJ.js';
 import * as _vue_skuilder_common from '@vue-skuilder/common';
 import { ClassroomConfig, DataShape, CourseElo, CourseConfig as CourseConfig$1 } from '@vue-skuilder/common';
 import { S as SyncStrategy, A as AccountCreationResult, a as AuthenticationResult } from '../../SyncStrategy-CyATpyLQ.js';
@@ -279,8 +279,40 @@ declare class CourseDB implements CourseDBInterface {
      * @returns Cards sorted by score descending
      */
     private _pendingHints;
+    /**
+     * Session-scoped cache of the broad ELO-neighbor pool used by
+     * getCardsCenteredAtELO. The `elo` view query re-indexes on first touch per
+     * call (PouchDB 9 ignores `stale`), so without this each plan/replan pays
+     * ~1.5-2s. The pool is fetched once and re-ranked against the live (roaming)
+     * ELO in memory on subsequent calls.
+     */
+    private _eloPoolCache;
+    private readonly _eloPoolTtlMs;
+    /**
+     * Cached assembled navigator (Pipeline). createNavigator() reads strategy
+     * docs and builds a fresh Pipeline every call — whose internal `_tagCache`
+     * and `_cachedOrchestration` are designed to make replans cheap but never
+     * survive, because the instance is discarded each run. Caching it lets those
+     * caches persist across plan/replan within a session (SessionController holds
+     * one CourseDB instance for the session's lifetime). Rebuilt on user change,
+     * TTL expiry, or explicit invalidation after a strategy-doc write.
+     */
+    private _cachedNavigator;
+    private readonly _navigatorTtlMs;
     setEphemeralHints(hints: ReplanHints): void;
     getWeightedCards(limit: number): Promise<GeneratorResult>;
+    /**
+     * Return the assembled navigator, reusing the cached instance when possible.
+     * Reuse preserves the Pipeline's per-session caches (tags, orchestration
+     * context) across replans, which is the dominant per-replan cost once the
+     * ELO-pool cost is removed. Rebuilds on user change or TTL expiry.
+     */
+    private _getCachedNavigator;
+    /**
+     * Drop the cached navigator so the next getWeightedCards() rebuilds it.
+     * Call after mutating this course's navigation strategy documents.
+     */
+    invalidateNavigatorCache(): void;
     getCardsCenteredAtELO(options?: {
         limit: number;
         elo: 'user' | 'random' | number;

package/dist/impl/couch/index.js

@@ -1753,10 +1753,8 @@ var init_elo = __esm({
           { limit, elo: "user" },
           (c) => !activeCards.some((ac) => c.cardID === ac.cardID)
         )).map((c) => ({ ...c, status: "new" }));
-        const cardIds = newCards.map((c) => c.cardID);
-        const cardEloData = await this.course.getCardEloData(cardIds);
-        const scored = newCards.map((c, i) => {
-          const cardElo = cardEloData[i]?.global?.score ?? 1e3;
+        const scored = newCards.map((c) => {
+          const cardElo = c.elo ?? 1e3;
           const distance = Math.abs(cardElo - userGlobalElo);
           const rawScore = Math.max(0, 1 - distance / 500);
           const samplingKey = rawScore > 0 ? Math.random() ** (1 / rawScore) : 0;
@@ -3734,7 +3732,8 @@ var init_orchestration = __esm({
 // src/core/navigators/Pipeline.ts
 var Pipeline_exports = {};
 __export(Pipeline_exports, {
-  Pipeline: () => Pipeline
+  Pipeline: () => Pipeline,
+  mergeHints: () => mergeHints2
 });
 function globToRegex(pattern) {
   const escaped = pattern.replace(/[.+?^${}()|[\]\\]/g, "\\$&");
@@ -5468,6 +5467,7 @@ ${above.rows.map((r) => `	${r.id}-${r.key}
       }
       async addNavigationStrategy(data) {
         logger.debug(`[courseDB] Adding navigation strategy: ${data._id}`);
+        this.invalidateNavigatorCache();
         return this.remoteDB.put(data).then(() => {
         });
       }
@@ -5534,23 +5534,67 @@ ${e.stack}` : JSON.stringify(e);
        * @returns Cards sorted by score descending
        */
       _pendingHints = null;
+      /**
+       * Session-scoped cache of the broad ELO-neighbor pool used by
+       * getCardsCenteredAtELO. The `elo` view query re-indexes on first touch per
+       * call (PouchDB 9 ignores `stale`), so without this each plan/replan pays
+       * ~1.5-2s. The pool is fetched once and re-ranked against the live (roaming)
+       * ELO in memory on subsequent calls.
+       */
+      _eloPoolCache = null;
+      _eloPoolTtlMs = 5 * 60 * 1e3;
+      /**
+       * Cached assembled navigator (Pipeline). createNavigator() reads strategy
+       * docs and builds a fresh Pipeline every call — whose internal `_tagCache`
+       * and `_cachedOrchestration` are designed to make replans cheap but never
+       * survive, because the instance is discarded each run. Caching it lets those
+       * caches persist across plan/replan within a session (SessionController holds
+       * one CourseDB instance for the session's lifetime). Rebuilt on user change,
+       * TTL expiry, or explicit invalidation after a strategy-doc write.
+       */
+      _cachedNavigator = null;
+      _navigatorTtlMs = 5 * 60 * 1e3;
       setEphemeralHints(hints) {
         this._pendingHints = hints;
       }
       async getWeightedCards(limit) {
         const u = await this._getCurrentUser();
         try {
-          const navigator2 = await this.createNavigator(u);
+          const { navigator: navigator2 } = await this._getCachedNavigator(u);
           if (this._pendingHints) {
             navigator2.setEphemeralHints(this._pendingHints);
             this._pendingHints = null;
           }
-          return navigator2.getWeightedCards(limit);
+          const result = await navigator2.getWeightedCards(limit);
+          return result;
         } catch (e) {
           logger.error(`[courseDB] Error getting weighted cards: ${e}`);
           throw e;
         }
       }
+      /**
+       * Return the assembled navigator, reusing the cached instance when possible.
+       * Reuse preserves the Pipeline's per-session caches (tags, orchestration
+       * context) across replans, which is the dominant per-replan cost once the
+       * ELO-pool cost is removed. Rebuilds on user change or TTL expiry.
+       */
+      async _getCachedNavigator(user) {
+        const userId = user.getUsername();
+        const now = Date.now();
+        if (this._cachedNavigator && this._cachedNavigator.userId === userId && now - this._cachedNavigator.builtAt < this._navigatorTtlMs) {
+          return { navigator: this._cachedNavigator.navigator, cacheStatus: "hit" };
+        }
+        const navigator2 = await this.createNavigator(user);
+        this._cachedNavigator = { navigator: navigator2, userId, builtAt: now };
+        return { navigator: navigator2, cacheStatus: "miss" };
+      }
+      /**
+       * Drop the cached navigator so the next getWeightedCards() rebuilds it.
+       * Call after mutating this course's navigation strategy documents.
+       */
+      invalidateNavigatorCache() {
+        this._cachedNavigator = null;
+      }
       async getCardsCenteredAtELO(options = {
         limit: 99,
         elo: "user"
@@ -5573,20 +5617,31 @@ ${e.stack}` : JSON.stringify(e);
         } 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 POOL_SIZE = Math.max(2e3, options.limit * 4);
+        const nowMs = Date.now();
+        let cacheStatus = "hit";
+        if (!this._eloPoolCache || nowMs - this._eloPoolCache.fetchedAt > this._eloPoolTtlMs) {
+          const fetched = await this.getCardsByELO(targetElo, POOL_SIZE);
+          if (fetched.length > 0) {
+            this._eloPoolCache = { rows: fetched, fetchedAt: nowMs };
+          }
+          cacheStatus = "miss";
+        }
+        const rankAgainstCurrentElo = () => {
+          const raw = this._eloPoolCache?.rows ?? [];
+          const survivors = filter ? raw.filter((c) => filter(c)) : raw;
+          return survivors.map((c) => ({ ...c })).sort(
+            (a, b) => Math.abs((a.elo ?? targetElo) - targetElo) - Math.abs((b.elo ?? targetElo) - targetElo)
+          );
+        };
+        let cards = rankAgainstCurrentElo();
+        if (cards.length < options.limit && (cacheStatus === "hit" || !this._eloPoolCache)) {
+          const fetched = await this.getCardsByELO(targetElo, POOL_SIZE);
+          if (fetched.length > 0) {
+            this._eloPoolCache = { rows: fetched, fetchedAt: nowMs };
+          }
+          cards = rankAgainstCurrentElo();
+          cacheStatus = "refresh";
         }
         const selectedCards = [];
         while (selectedCards.length < options.limit && cards.length > 0) {