@vue-skuilder/db 0.1.18 → 0.1.21

package/dist/index.mjs

@@ -1,10 +1,5 @@
 var __defProp = Object.defineProperty;
 var __getOwnPropNames = Object.getOwnPropertyNames;
-var __glob = (map) => (path3) => {
-  var fn = map[path3];
-  if (fn) return fn();
-  throw new Error("Module not found in bundle: " + path3);
-};
 var __esm = (fn, res) => function __init() {
   return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
 };
@@ -100,6 +95,7 @@ var init_types_legacy = __esm({
       DocType3["SCHEDULED_CARD"] = "SCHEDULED_CARD";
       DocType3["TAG"] = "TAG";
       DocType3["NAVIGATION_STRATEGY"] = "NAVIGATION_STRATEGY";
+      DocType3["STRATEGY_STATE"] = "STRATEGY_STATE";
       return DocType3;
     })(DocType || {});
     DocTypePrefixes = {
@@ -113,7 +109,8 @@ var init_types_legacy = __esm({
       ["QUESTION" /* QUESTIONTYPE */]: "QUESTION",
       ["VIEW" /* VIEW */]: "VIEW",
       ["PEDAGOGY" /* PEDAGOGY */]: "PEDAGOGY",
-      ["NAVIGATION_STRATEGY" /* NAVIGATION_STRATEGY */]: "NAVIGATION_STRATEGY"
+      ["NAVIGATION_STRATEGY" /* NAVIGATION_STRATEGY */]: "NAVIGATION_STRATEGY",
+      ["STRATEGY_STATE" /* STRATEGY_STATE */]: "STRATEGY_STATE"
     };
   }
 });
@@ -164,6 +161,9 @@ var init_pouchdb_setup = __esm({
     "use strict";
     PouchDB.plugin(PouchDBFind);
     PouchDB.plugin(PouchDBAuth);
+    if (typeof PouchDB.debug !== "undefined") {
+      PouchDB.debug.disable();
+    }
     PouchDB.defaults({
       // ajax: {
       //   timeout: 60000,
@@ -173,112 +173,21 @@ var init_pouchdb_setup = __esm({
   }
 });
 
-// src/util/tuiLogger.ts
+// src/util/dataDirectory.ts
 import * as fs from "fs";
 import * as path from "path";
-function initializeTuiLogging() {
-  isNodeEnvironment = typeof window === "undefined" && typeof process !== "undefined";
-  if (!isNodeEnvironment) {
-    return;
-  }
-  try {
-    logFile = path.join(getAppDataDirectory(), "lastrun.log");
-    if (fs.existsSync(logFile)) {
-      fs.unlinkSync(logFile);
-    }
-    const startTime = (/* @__PURE__ */ new Date()).toISOString();
-    fs.writeFileSync(logFile, `=== TUI Session Started: ${startTime} ===
-`);
-    const originalConsole = {
-      // eslint-disable-next-line no-console
-      log: console.log,
-      // eslint-disable-next-line no-console
-      error: console.error,
-      // eslint-disable-next-line no-console
-      warn: console.warn,
-      // eslint-disable-next-line no-console
-      info: console.info
-    };
-    const writeToLog = (level, args) => {
-      const timestamp = (/* @__PURE__ */ new Date()).toISOString();
-      const message = args.map(
-        (arg) => typeof arg === "object" ? JSON.stringify(arg, null, 2) : String(arg)
-      ).join(" ");
-      const logEntry = `[${timestamp}] ${level}: ${message}
-`;
-      try {
-        fs.appendFileSync(logFile, logEntry);
-      } catch (err) {
-        originalConsole.error("Failed to write to log file:", err);
-        originalConsole[level.toLowerCase()](...args);
-      }
-    };
-    console.log = (...args) => writeToLog("INFO", args);
-    console.info = (...args) => writeToLog("INFO", args);
-    console.warn = (...args) => writeToLog("WARN", args);
-    console.error = (...args) => writeToLog("ERROR", args);
-    console._originalMethods = originalConsole;
-    console.log("TUI logging initialized - logs redirected to", logFile);
-  } catch (err) {
-    console.error("Failed to initialize TUI logging:", err);
-  }
-}
-function getLogFilePath() {
-  return logFile;
-}
-function showUserMessage(message) {
-  if (isNodeEnvironment) {
-    process.stdout.write(message + "\n");
-  } else {
-    console.log(message);
-  }
-}
-function showUserError(message) {
-  if (isNodeEnvironment) {
-    process.stderr.write("Error: " + message + "\n");
-  } else {
-    console.error(message);
-  }
-}
-var logFile, isNodeEnvironment, logger2;
-var init_tuiLogger = __esm({
-  "src/util/tuiLogger.ts"() {
-    "use strict";
-    init_dataDirectory();
-    logFile = null;
-    isNodeEnvironment = false;
-    logger2 = {
-      debug: (message, ...args) => {
-        console.log(`[DEBUG] ${message}`, ...args);
-      },
-      info: (message, ...args) => {
-        console.info(`[INFO] ${message}`, ...args);
-      },
-      warn: (message, ...args) => {
-        console.warn(`[WARN] ${message}`, ...args);
-      },
-      error: (message, ...args) => {
-        console.error(`[ERROR] ${message}`, ...args);
-      }
-    };
-  }
-});
-
-// src/util/dataDirectory.ts
-import * as fs2 from "fs";
-import * as path2 from "path";
 import * as os from "os";
 function getAppDataDirectory() {
   if (ENV.LOCAL_STORAGE_PREFIX) {
-    return path2.join(os.homedir(), `.tuilder`, ENV.LOCAL_STORAGE_PREFIX);
+    return path.join(os.homedir(), `.tuilder`, ENV.LOCAL_STORAGE_PREFIX);
   } else {
-    return path2.join(os.homedir(), ".tuilder");
+    return path.join(os.homedir(), ".tuilder");
   }
 }
 async function ensureAppDataDirectory() {
   const appDataDir = getAppDataDirectory();
   try {
-    await fs2.promises.mkdir(appDataDir, { recursive: true });
+    await fs.promises.mkdir(appDataDir, { recursive: true });
   } catch (err) {
     if (err.code !== "EEXIST") {
       throw new Error(`Failed to create app data directory ${appDataDir}: ${err.message}`);
@@ -287,16 +196,16 @@ async function ensureAppDataDirectory() {
   return appDataDir;
 }
 function getDbPath(dbName) {
-  return path2.join(getAppDataDirectory(), dbName);
+  return path.join(getAppDataDirectory(), dbName);
 }
 async function initializeDataDirectory() {
   await ensureAppDataDirectory();
-  logger2.info(`PouchDB data directory initialized: ${getAppDataDirectory()}`);
+  logger.info(`PouchDB data directory initialized: ${getAppDataDirectory()}`);
 }
 var init_dataDirectory = __esm({
   "src/util/dataDirectory.ts"() {
     "use strict";
-    init_tuiLogger();
+    init_logger();
     init_factory();
   }
 });
@@ -922,196 +831,223 @@ var init_courseLookupDB = __esm({
   }
 });
 
-// src/core/navigators/CompositeGenerator.ts
-var CompositeGenerator_exports = {};
-__export(CompositeGenerator_exports, {
-  AggregationMode: () => AggregationMode,
-  default: () => CompositeGenerator
-});
-var AggregationMode, DEFAULT_AGGREGATION_MODE, FREQUENCY_BOOST_FACTOR, CompositeGenerator;
-var init_CompositeGenerator = __esm({
-  "src/core/navigators/CompositeGenerator.ts"() {
+// src/core/navigators/index.ts
+function getCardOrigin(card) {
+  if (card.provenance.length === 0) {
+    throw new Error("Card has no provenance - cannot determine origin");
+  }
+  const firstEntry = card.provenance[0];
+  const reason = firstEntry.reason.toLowerCase();
+  if (reason.includes("failed")) {
+    return "failed";
+  }
+  if (reason.includes("review")) {
+    return "review";
+  }
+  return "new";
+}
+function isGenerator(impl) {
+  return NavigatorRoles[impl] === "generator" /* GENERATOR */;
+}
+function isFilter(impl) {
+  return NavigatorRoles[impl] === "filter" /* FILTER */;
+}
+var Navigators, NavigatorRole, NavigatorRoles, ContentNavigator;
+var init_navigators = __esm({
+  "src/core/navigators/index.ts"() {
     "use strict";
-    init_navigators();
     init_logger();
-    AggregationMode = /* @__PURE__ */ ((AggregationMode2) => {
-      AggregationMode2["MAX"] = "max";
-      AggregationMode2["AVERAGE"] = "average";
-      AggregationMode2["FREQUENCY_BOOST"] = "frequencyBoost";
-      return AggregationMode2;
-    })(AggregationMode || {});
-    DEFAULT_AGGREGATION_MODE = "frequencyBoost" /* FREQUENCY_BOOST */;
-    FREQUENCY_BOOST_FACTOR = 0.1;
-    CompositeGenerator = class _CompositeGenerator extends ContentNavigator {
-      /** Human-readable name for CardGenerator interface */
-      name = "Composite Generator";
-      generators;
-      aggregationMode;
-      constructor(generators, aggregationMode = DEFAULT_AGGREGATION_MODE) {
-        super();
-        this.generators = generators;
-        this.aggregationMode = aggregationMode;
-        if (generators.length === 0) {
-          throw new Error("CompositeGenerator requires at least one generator");
-        }
-        logger.debug(
-          `[CompositeGenerator] Created with ${generators.length} generators, mode: ${aggregationMode}`
-        );
-      }
+    Navigators = /* @__PURE__ */ ((Navigators2) => {
+      Navigators2["ELO"] = "elo";
+      Navigators2["SRS"] = "srs";
+      Navigators2["HIERARCHY"] = "hierarchyDefinition";
+      Navigators2["INTERFERENCE"] = "interferenceMitigator";
+      Navigators2["RELATIVE_PRIORITY"] = "relativePriority";
+      Navigators2["USER_TAG_PREFERENCE"] = "userTagPreference";
+      return Navigators2;
+    })(Navigators || {});
+    NavigatorRole = /* @__PURE__ */ ((NavigatorRole2) => {
+      NavigatorRole2["GENERATOR"] = "generator";
+      NavigatorRole2["FILTER"] = "filter";
+      return NavigatorRole2;
+    })(NavigatorRole || {});
+    NavigatorRoles = {
+      ["elo" /* ELO */]: "generator" /* GENERATOR */,
+      ["srs" /* SRS */]: "generator" /* GENERATOR */,
+      ["hierarchyDefinition" /* HIERARCHY */]: "filter" /* FILTER */,
+      ["interferenceMitigator" /* INTERFERENCE */]: "filter" /* FILTER */,
+      ["relativePriority" /* RELATIVE_PRIORITY */]: "filter" /* FILTER */,
+      ["userTagPreference" /* USER_TAG_PREFERENCE */]: "filter" /* FILTER */
+    };
+    ContentNavigator = class {
+      /** User interface for this navigation session */
+      user;
+      /** Course interface for this navigation session */
+      course;
+      /** Human-readable name for this strategy instance (from ContentNavigationStrategyData.name) */
+      strategyName;
+      /** Unique document ID for this strategy instance (from ContentNavigationStrategyData._id) */
+      strategyId;
       /**
-       * Creates a CompositeGenerator from strategy data.
+       * Constructor for standard navigators.
+       * Call this from subclass constructors to initialize common fields.
        *
-       * This is a convenience factory for use by PipelineAssembler.
+       * Note: CompositeGenerator and Pipeline call super() without args, then set
+       * user/course fields directly if needed.
        */
-      static async fromStrategies(user, course, strategies, aggregationMode = DEFAULT_AGGREGATION_MODE) {
-        const generators = await Promise.all(
-          strategies.map((s) => ContentNavigator.create(user, course, s))
-        );
-        return new _CompositeGenerator(generators, aggregationMode);
+      constructor(user, course, strategyData) {
+        this.user = user;
+        this.course = course;
+        if (strategyData) {
+          this.strategyName = strategyData.name;
+          this.strategyId = strategyData._id;
+        }
       }
+      // ============================================================================
+      // STRATEGY STATE HELPERS
+      // ============================================================================
+      //
+      // These methods allow strategies to persist their own state (user preferences,
+      // learned patterns, temporal tracking) in the user database.
+      //
+      // ============================================================================
       /**
-       * Get weighted cards from all generators, merge and deduplicate.
-       *
-       * Cards appearing in multiple generators receive a score boost.
-       * Provenance tracks which generators produced each card and how scores were aggregated.
+       * Unique key identifying this strategy for state storage.
        *
-       * This method supports both the legacy signature (limit only) and the
-       * CardGenerator interface signature (limit, context).
-       *
-       * @param limit - Maximum number of cards to return
-       * @param context - Optional GeneratorContext passed to child generators
+       * Defaults to the constructor name (e.g., "UserTagPreferenceFilter").
+       * Override in subclasses if multiple instances of the same strategy type
+       * need separate state storage.
        */
-      async getWeightedCards(limit, context) {
-        const results = await Promise.all(
-          this.generators.map((g) => g.getWeightedCards(limit, context))
-        );
-        const byCardId = /* @__PURE__ */ new Map();
-        for (const cards of results) {
-          for (const card of cards) {
-            const existing = byCardId.get(card.cardId) || [];
-            existing.push(card);
-            byCardId.set(card.cardId, existing);
-          }
-        }
-        const merged = [];
-        for (const [, cards] of byCardId) {
-          const aggregatedScore = this.aggregateScores(cards);
-          const finalScore = Math.min(1, aggregatedScore);
-          const mergedProvenance = cards.flatMap((c) => c.provenance);
-          const initialScore = cards[0].score;
-          const action = finalScore > initialScore ? "boosted" : finalScore < initialScore ? "penalized" : "passed";
-          const reason = this.buildAggregationReason(cards, finalScore);
-          merged.push({
-            ...cards[0],
-            score: finalScore,
-            provenance: [
-              ...mergedProvenance,
-              {
-                strategy: "composite",
-                strategyName: "Composite Generator",
-                strategyId: "COMPOSITE_GENERATOR",
-                action,
-                score: finalScore,
-                reason
-              }
-            ]
-          });
-        }
-        return merged.sort((a, b) => b.score - a.score).slice(0, limit);
+      get strategyKey() {
+        return this.constructor.name;
       }
       /**
-       * Build human-readable reason for score aggregation.
+       * Get this strategy's persisted state for the current course.
+       *
+       * @returns The strategy's data payload, or null if no state exists
+       * @throws Error if user or course is not initialized
        */
-      buildAggregationReason(cards, finalScore) {
-        const count = cards.length;
-        const scores = cards.map((c) => c.score.toFixed(2)).join(", ");
-        if (count === 1) {
-          return `Single generator, score ${finalScore.toFixed(2)}`;
-        }
-        const strategies = cards.map((c) => c.provenance[0]?.strategy || "unknown").join(", ");
-        switch (this.aggregationMode) {
-          case "max" /* MAX */:
-            return `Max of ${count} generators (${strategies}): scores [${scores}] \u2192 ${finalScore.toFixed(2)}`;
-          case "average" /* AVERAGE */:
-            return `Average of ${count} generators (${strategies}): scores [${scores}] \u2192 ${finalScore.toFixed(2)}`;
-          case "frequencyBoost" /* FREQUENCY_BOOST */: {
-            const avg = cards.reduce((sum, c) => sum + c.score, 0) / count;
-            const boost = 1 + FREQUENCY_BOOST_FACTOR * (count - 1);
-            return `Frequency boost from ${count} generators (${strategies}): avg ${avg.toFixed(2)} \xD7 ${boost.toFixed(2)} \u2192 ${finalScore.toFixed(2)}`;
-          }
-          default:
-            return `Aggregated from ${count} generators: ${finalScore.toFixed(2)}`;
+      async getStrategyState() {
+        if (!this.user || !this.course) {
+          throw new Error(
+            `Cannot get strategy state: navigator not properly initialized. Ensure user and course are provided to constructor.`
+          );
         }
+        return this.user.getStrategyState(this.course.getCourseID(), this.strategyKey);
       }
       /**
-       * Aggregate scores from multiple generators for the same card.
+       * Persist this strategy's state for the current course.
+       *
+       * @param data - The strategy's data payload to store
+       * @throws Error if user or course is not initialized
        */
-      aggregateScores(cards) {
-        const scores = cards.map((c) => c.score);
-        switch (this.aggregationMode) {
-          case "max" /* MAX */:
-            return Math.max(...scores);
-          case "average" /* AVERAGE */:
-            return scores.reduce((sum, s) => sum + s, 0) / scores.length;
-          case "frequencyBoost" /* FREQUENCY_BOOST */: {
-            const avg = scores.reduce((sum, s) => sum + s, 0) / scores.length;
-            const frequencyBoost = 1 + FREQUENCY_BOOST_FACTOR * (cards.length - 1);
-            return avg * frequencyBoost;
-          }
-          default:
-            return scores[0];
+      async putStrategyState(data) {
+        if (!this.user || !this.course) {
+          throw new Error(
+            `Cannot put strategy state: navigator not properly initialized. Ensure user and course are provided to constructor.`
+          );
         }
+        return this.user.putStrategyState(this.course.getCourseID(), this.strategyKey, data);
       }
       /**
-       * Get new cards from all generators, merged and deduplicated.
+       * Factory method to create navigator instances dynamically.
+       *
+       * @param user - User interface
+       * @param course - Course interface
+       * @param strategyData - Strategy configuration document
+       * @returns the runtime object used to steer a study session.
        */
-      async getNewCards(n) {
-        const legacyGenerators = this.generators.filter(
-          (g) => g instanceof ContentNavigator
-        );
-        const results = await Promise.all(legacyGenerators.map((g) => g.getNewCards(n)));
-        const seen = /* @__PURE__ */ new Set();
-        const merged = [];
-        for (const cards of results) {
-          for (const card of cards) {
-            if (!seen.has(card.cardID)) {
-              seen.add(card.cardID);
-              merged.push(card);
+      static async create(user, course, strategyData) {
+        const implementingClass = strategyData.implementingClass;
+        let NavigatorImpl;
+        const variations = [".ts", ".js", ""];
+        const dirs = ["filters", "generators"];
+        for (const ext of variations) {
+          for (const dir of dirs) {
+            const loadFrom = `./${dir}/${implementingClass}${ext}`;
+            try {
+              const module = await import(loadFrom);
+              NavigatorImpl = module.default;
+              break;
+            } catch (e) {
+              logger.debug(`Failed to load extension from ${loadFrom}:`, e);
             }
           }
         }
-        return n ? merged.slice(0, n) : merged;
+        if (!NavigatorImpl) {
+          throw new Error(`Could not load navigator implementation for: ${implementingClass}`);
+        }
+        return new NavigatorImpl(user, course, strategyData);
       }
       /**
-       * Get pending reviews from all generators, merged and deduplicated.
+       * Get cards with suitability scores and provenance trails.
+       *
+       * **This is the PRIMARY API for navigation strategies.**
+       *
+       * Returns cards ranked by suitability score (0-1). Higher scores indicate
+       * better candidates for presentation. Each card includes a provenance trail
+       * documenting how strategies contributed to the final score.
+       *
+       * ## Implementation Required
+       * All navigation strategies MUST override this method. The base class does
+       * not provide a default implementation.
+       *
+       * ## For Generators
+       * Override this method to generate candidates and compute scores based on
+       * your strategy's logic (e.g., ELO proximity, review urgency). Create the
+       * initial provenance entry with action='generated'.
+       *
+       * ## For Filters
+       * Filters should implement the CardFilter interface instead and be composed
+       * via Pipeline. Filters do not directly implement getWeightedCards().
+       *
+       * @param limit - Maximum cards to return
+       * @returns Cards sorted by score descending, with provenance trails
        */
-      async getPendingReviews() {
-        const legacyGenerators = this.generators.filter(
-          (g) => g instanceof ContentNavigator
-        );
-        const results = await Promise.all(legacyGenerators.map((g) => g.getPendingReviews()));
-        const seen = /* @__PURE__ */ new Set();
-        const merged = [];
-        for (const reviews of results) {
-          for (const review of reviews) {
-            if (!seen.has(review.cardID)) {
-              seen.add(review.cardID);
-              merged.push(review);
-            }
-          }
-        }
-        return merged;
+      async getWeightedCards(_limit) {
+        throw new Error(`${this.constructor.name} must implement getWeightedCards(). `);
       }
     };
   }
 });
 
 // src/core/navigators/Pipeline.ts
-var Pipeline_exports = {};
-__export(Pipeline_exports, {
-  Pipeline: () => Pipeline
-});
 import { toCourseElo as toCourseElo2 } from "@vue-skuilder/common";
+function logPipelineConfig(generator, filters) {
+  const filterList = filters.length > 0 ? "\n    - " + filters.map((f) => f.name).join("\n    - ") : " none";
+  logger.info(
+    `[Pipeline] Configuration:
+  Generator: ${generator.name}
+  Filters:${filterList}`
+  );
+}
+function logTagHydration(cards, tagsByCard) {
+  const totalTags = Array.from(tagsByCard.values()).reduce((sum, tags) => sum + tags.length, 0);
+  const cardsWithTags = Array.from(tagsByCard.values()).filter((tags) => tags.length > 0).length;
+  logger.debug(
+    `[Pipeline] Tag hydration: ${cards.length} cards, ${cardsWithTags} have tags (${totalTags} total tags) - single batch query`
+  );
+}
+function logExecutionSummary(generatorName, generatedCount, filterCount, finalCount, topScores) {
+  const scoreDisplay = topScores.length > 0 ? topScores.map((s) => s.toFixed(2)).join(", ") : "none";
+  logger.info(
+    `[Pipeline] Execution: ${generatorName} produced ${generatedCount} \u2192 ${filterCount} filters \u2192 ${finalCount} results (top scores: ${scoreDisplay})`
+  );
+}
+function logCardProvenance(cards, maxCards = 3) {
+  const cardsToLog = cards.slice(0, maxCards);
+  logger.debug(`[Pipeline] Provenance for top ${cardsToLog.length} cards:`);
+  for (const card of cardsToLog) {
+    logger.debug(`[Pipeline]   ${card.cardId} (final score: ${card.score.toFixed(3)}):`);
+    for (const entry of card.provenance) {
+      const scoreChange = entry.score.toFixed(3);
+      const action = entry.action.padEnd(9);
+      logger.debug(
+        `[Pipeline]     ${action} ${scoreChange} - ${entry.strategyName}: ${entry.reason}`
+      );
+    }
+  }
+}
 var Pipeline;
 var init_Pipeline = __esm({
   "src/core/navigators/Pipeline.ts"() {
@@ -1135,19 +1071,23 @@ var init_Pipeline = __esm({
         this.filters = filters;
         this.user = user;
         this.course = course;
-        logger.debug(
-          `[Pipeline] Created with generator '${generator.name}' and ${filters.length} filters: ${filters.map((f) => f.name).join(", ")}`
-        );
+        course.getCourseConfig().then((cfg) => {
+          logger.debug(`[pipeline] Crated pipeline for ${cfg.name}`);
+        }).catch((e) => {
+          logger.error(`[pipeline] Failed to lookup courseCfg: ${e}`);
+        });
+        logPipelineConfig(generator, filters);
       }
       /**
        * Get weighted cards by running generator and applying filters.
        *
        * 1. Build shared context (user ELO, etc.)
        * 2. Get candidates from generator (passing context)
-       * 3. Apply each filter sequentially
-       * 4. Remove zero-score cards
-       * 5. Sort by score descending
-       * 6. Return top N
+       * 3. Batch hydrate tags for all candidates
+       * 4. Apply each filter sequentially
+       * 5. Remove zero-score cards
+       * 6. Sort by score descending
+       * 7. Return top N
        *
        * @param limit - Maximum number of cards to return
        * @returns Cards sorted by score descending
@@ -1160,7 +1100,9 @@ var init_Pipeline = __esm({
           `[Pipeline] Fetching ${fetchLimit} candidates from generator '${this.generator.name}'`
         );
         let cards = await this.generator.getWeightedCards(fetchLimit, context);
-        logger.debug(`[Pipeline] Generator returned ${cards.length} candidates`);
+        const generatedCount = cards.length;
+        logger.debug(`[Pipeline] Generator returned ${generatedCount} candidates`);
+        cards = await this.hydrateTags(cards);
         for (const filter of this.filters) {
           const beforeCount = cards.length;
           cards = await filter.transform(cards, context);
@@ -1169,11 +1111,39 @@ var init_Pipeline = __esm({
         cards = cards.filter((c) => c.score > 0);
         cards.sort((a, b) => b.score - a.score);
         const result = cards.slice(0, limit);
-        logger.debug(
-          `[Pipeline] Returning ${result.length} cards (top scores: ${result.slice(0, 3).map((c) => c.score.toFixed(2)).join(", ")}...)`
+        const topScores = result.slice(0, 3).map((c) => c.score);
+        logExecutionSummary(
+          this.generator.name,
+          generatedCount,
+          this.filters.length,
+          result.length,
+          topScores
         );
+        logCardProvenance(result, 3);
         return result;
       }
+      /**
+       * Batch hydrate tags for all cards.
+       *
+       * Fetches tags for all cards in a single database query and attaches them
+       * to the WeightedCard objects. Filters can then use card.tags instead of
+       * making individual getAppliedTags() calls.
+       *
+       * @param cards - Cards to hydrate
+       * @returns Cards with tags populated
+       */
+      async hydrateTags(cards) {
+        if (cards.length === 0) {
+          return cards;
+        }
+        const cardIds = cards.map((c) => c.cardId);
+        const tagsByCard = await this.course.getAppliedTagsBatch(cardIds);
+        logTagHydration(cards, tagsByCard);
+        return cards.map((card) => ({
+          ...card,
+          tags: tagsByCard.get(card.cardId) ?? []
+        }));
+      }
       /**
        * Build shared context for generator and filters.
        *
@@ -1197,48 +1167,155 @@ var init_Pipeline = __esm({
           userElo
         };
       }
-      // ===========================================================================
-      // Legacy StudyContentSource methods
-      // ===========================================================================
-      //
-      // These delegate to the generator for backward compatibility.
-      // Eventually SessionController will use getWeightedCards() exclusively.
-      //
       /**
-       * Get new cards via legacy API.
-       * Delegates to the generator if it supports the legacy interface.
+       * Get the course ID for this pipeline.
        */
-      async getNewCards(n) {
-        if ("getNewCards" in this.generator && typeof this.generator.getNewCards === "function") {
-          return this.generator.getNewCards(n);
+      getCourseID() {
+        return this.course.getCourseID();
+      }
+    };
+  }
+});
+
+// src/core/navigators/generators/CompositeGenerator.ts
+var DEFAULT_AGGREGATION_MODE, FREQUENCY_BOOST_FACTOR, CompositeGenerator;
+var init_CompositeGenerator = __esm({
+  "src/core/navigators/generators/CompositeGenerator.ts"() {
+    "use strict";
+    init_navigators();
+    init_logger();
+    DEFAULT_AGGREGATION_MODE = "frequencyBoost" /* FREQUENCY_BOOST */;
+    FREQUENCY_BOOST_FACTOR = 0.1;
+    CompositeGenerator = class _CompositeGenerator extends ContentNavigator {
+      /** Human-readable name for CardGenerator interface */
+      name = "Composite Generator";
+      generators;
+      aggregationMode;
+      constructor(generators, aggregationMode = DEFAULT_AGGREGATION_MODE) {
+        super();
+        this.generators = generators;
+        this.aggregationMode = aggregationMode;
+        if (generators.length === 0) {
+          throw new Error("CompositeGenerator requires at least one generator");
         }
-        return [];
+        logger.debug(
+          `[CompositeGenerator] Created with ${generators.length} generators, mode: ${aggregationMode}`
+        );
       }
       /**
-       * Get pending reviews via legacy API.
-       * Delegates to the generator if it supports the legacy interface.
+       * Creates a CompositeGenerator from strategy data.
+       *
+       * This is a convenience factory for use by PipelineAssembler.
        */
-      async getPendingReviews() {
-        if ("getPendingReviews" in this.generator && typeof this.generator.getPendingReviews === "function") {
-          return this.generator.getPendingReviews();
+      static async fromStrategies(user, course, strategies, aggregationMode = DEFAULT_AGGREGATION_MODE) {
+        const generators = await Promise.all(
+          strategies.map((s) => ContentNavigator.create(user, course, s))
+        );
+        return new _CompositeGenerator(generators, aggregationMode);
+      }
+      /**
+       * Get weighted cards from all generators, merge and deduplicate.
+       *
+       * Cards appearing in multiple generators receive a score boost.
+       * Provenance tracks which generators produced each card and how scores were aggregated.
+       *
+       * This method supports both the legacy signature (limit only) and the
+       * CardGenerator interface signature (limit, context).
+       *
+       * @param limit - Maximum number of cards to return
+       * @param context - GeneratorContext passed to child generators (required when called via Pipeline)
+       */
+      async getWeightedCards(limit, context) {
+        if (!context) {
+          throw new Error(
+            "CompositeGenerator.getWeightedCards requires a GeneratorContext. It should be called via Pipeline, not directly."
+          );
         }
-        return [];
+        const results = await Promise.all(
+          this.generators.map((g) => g.getWeightedCards(limit, context))
+        );
+        const byCardId = /* @__PURE__ */ new Map();
+        for (const cards of results) {
+          for (const card of cards) {
+            const existing = byCardId.get(card.cardId) || [];
+            existing.push(card);
+            byCardId.set(card.cardId, existing);
+          }
+        }
+        const merged = [];
+        for (const [, cards] of byCardId) {
+          const aggregatedScore = this.aggregateScores(cards);
+          const finalScore = Math.min(1, aggregatedScore);
+          const mergedProvenance = cards.flatMap((c) => c.provenance);
+          const initialScore = cards[0].score;
+          const action = finalScore > initialScore ? "boosted" : finalScore < initialScore ? "penalized" : "passed";
+          const reason = this.buildAggregationReason(cards, finalScore);
+          merged.push({
+            ...cards[0],
+            score: finalScore,
+            provenance: [
+              ...mergedProvenance,
+              {
+                strategy: "composite",
+                strategyName: "Composite Generator",
+                strategyId: "COMPOSITE_GENERATOR",
+                action,
+                score: finalScore,
+                reason
+              }
+            ]
+          });
+        }
+        return merged.sort((a, b) => b.score - a.score).slice(0, limit);
       }
       /**
-       * Get the course ID for this pipeline.
+       * Build human-readable reason for score aggregation.
        */
-      getCourseID() {
-        return this.course.getCourseID();
+      buildAggregationReason(cards, finalScore) {
+        const count = cards.length;
+        const scores = cards.map((c) => c.score.toFixed(2)).join(", ");
+        if (count === 1) {
+          return `Single generator, score ${finalScore.toFixed(2)}`;
+        }
+        const strategies = cards.map((c) => c.provenance[0]?.strategy || "unknown").join(", ");
+        switch (this.aggregationMode) {
+          case "max" /* MAX */:
+            return `Max of ${count} generators (${strategies}): scores [${scores}] \u2192 ${finalScore.toFixed(2)}`;
+          case "average" /* AVERAGE */:
+            return `Average of ${count} generators (${strategies}): scores [${scores}] \u2192 ${finalScore.toFixed(2)}`;
+          case "frequencyBoost" /* FREQUENCY_BOOST */: {
+            const avg = cards.reduce((sum, c) => sum + c.score, 0) / count;
+            const boost = 1 + FREQUENCY_BOOST_FACTOR * (count - 1);
+            return `Frequency boost from ${count} generators (${strategies}): avg ${avg.toFixed(2)} \xD7 ${boost.toFixed(2)} \u2192 ${finalScore.toFixed(2)}`;
+          }
+          default:
+            return `Aggregated from ${count} generators: ${finalScore.toFixed(2)}`;
+        }
+      }
+      /**
+       * Aggregate scores from multiple generators for the same card.
+       */
+      aggregateScores(cards) {
+        const scores = cards.map((c) => c.score);
+        switch (this.aggregationMode) {
+          case "max" /* MAX */:
+            return Math.max(...scores);
+          case "average" /* AVERAGE */:
+            return scores.reduce((sum, s) => sum + s, 0) / scores.length;
+          case "frequencyBoost" /* FREQUENCY_BOOST */: {
+            const avg = scores.reduce((sum, s) => sum + s, 0) / scores.length;
+            const frequencyBoost = 1 + FREQUENCY_BOOST_FACTOR * (cards.length - 1);
+            return avg * frequencyBoost;
+          }
+          default:
+            return scores[0];
+        }
       }
     };
   }
 });
 
 // src/core/navigators/PipelineAssembler.ts
-var PipelineAssembler_exports = {};
-__export(PipelineAssembler_exports, {
-  PipelineAssembler: () => PipelineAssembler
-});
 var PipelineAssembler;
 var init_PipelineAssembler = __esm({
   "src/core/navigators/PipelineAssembler.ts"() {
@@ -1359,15 +1436,11 @@ var init_PipelineAssembler = __esm({
   }
 });
 
-// src/core/navigators/elo.ts
-var elo_exports = {};
-__export(elo_exports, {
-  default: () => ELONavigator
-});
+// src/core/navigators/generators/elo.ts
 import { toCourseElo as toCourseElo3 } from "@vue-skuilder/common";
 var ELONavigator;
 var init_elo = __esm({
-  "src/core/navigators/elo.ts"() {
+  "src/core/navigators/generators/elo.ts"() {
     "use strict";
     init_navigators();
     ELONavigator = class extends ContentNavigator {
@@ -1377,50 +1450,6 @@ var init_elo = __esm({
         super(user, course, strategyData);
         this.name = strategyData?.name || "ELO";
       }
-      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.cardID === ac.cardID)) {
-              return false;
-            } else {
-              return true;
-            }
-          }
-        )).map((c) => {
-          return {
-            ...c,
-            status: "new"
-          };
-        });
-      }
       /**
        * Get new cards with suitability scores based on ELO distance.
        *
@@ -1445,7 +1474,11 @@ var init_elo = __esm({
           const userElo = toCourseElo3(courseReg.elo);
           userGlobalElo = userElo.global.score;
         }
-        const newCards = await this.getNewCards(limit);
+        const activeCards = await this.user.getActiveCards();
+        const newCards = (await this.course.getCardsCenteredAtELO(
+          { 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) => {
@@ -1475,806 +1508,14 @@ var init_elo = __esm({
   }
 });
 
-// src/core/navigators/filters/eloDistance.ts
-var eloDistance_exports = {};
-__export(eloDistance_exports, {
-  DEFAULT_HALF_LIFE: () => DEFAULT_HALF_LIFE,
-  DEFAULT_MAX_MULTIPLIER: () => DEFAULT_MAX_MULTIPLIER,
-  DEFAULT_MIN_MULTIPLIER: () => DEFAULT_MIN_MULTIPLIER,
-  createEloDistanceFilter: () => createEloDistanceFilter
-});
-function computeMultiplier(distance, halfLife, minMultiplier, maxMultiplier) {
-  const normalizedDistance = distance / halfLife;
-  const decay = Math.exp(-(normalizedDistance * normalizedDistance));
-  return minMultiplier + (maxMultiplier - minMultiplier) * decay;
-}
-function createEloDistanceFilter(config) {
-  const halfLife = config?.halfLife ?? DEFAULT_HALF_LIFE;
-  const minMultiplier = config?.minMultiplier ?? DEFAULT_MIN_MULTIPLIER;
-  const maxMultiplier = config?.maxMultiplier ?? DEFAULT_MAX_MULTIPLIER;
-  return {
-    name: "ELO Distance Filter",
-    async transform(cards, context) {
-      const { course, userElo } = context;
-      const cardIds = cards.map((c) => c.cardId);
-      const cardElos = await course.getCardEloData(cardIds);
-      return cards.map((card, i) => {
-        const cardElo = cardElos[i]?.global?.score ?? 1e3;
-        const distance = Math.abs(cardElo - userElo);
-        const multiplier = computeMultiplier(distance, halfLife, minMultiplier, maxMultiplier);
-        const newScore = card.score * multiplier;
-        const action = multiplier < maxMultiplier - 0.01 ? "penalized" : "passed";
-        return {
-          ...card,
-          score: newScore,
-          provenance: [
-            ...card.provenance,
-            {
-              strategy: "eloDistance",
-              strategyName: "ELO Distance Filter",
-              strategyId: "ELO_DISTANCE_FILTER",
-              action,
-              score: newScore,
-              reason: `ELO distance ${Math.round(distance)} (card: ${Math.round(cardElo)}, user: ${Math.round(userElo)}) \u2192 ${multiplier.toFixed(2)}x`
-            }
-          ]
-        };
-      });
-    }
-  };
-}
-var DEFAULT_HALF_LIFE, DEFAULT_MIN_MULTIPLIER, DEFAULT_MAX_MULTIPLIER;
-var init_eloDistance = __esm({
-  "src/core/navigators/filters/eloDistance.ts"() {
-    "use strict";
-    DEFAULT_HALF_LIFE = 200;
-    DEFAULT_MIN_MULTIPLIER = 0.3;
-    DEFAULT_MAX_MULTIPLIER = 1;
-  }
-});
-
-// src/core/navigators/filters/index.ts
-var filters_exports = {};
-__export(filters_exports, {
-  createEloDistanceFilter: () => createEloDistanceFilter
-});
-var init_filters = __esm({
-  "src/core/navigators/filters/index.ts"() {
-    "use strict";
-    init_eloDistance();
-  }
-});
-
-// src/core/navigators/filters/types.ts
-var types_exports = {};
-var init_types = __esm({
-  "src/core/navigators/filters/types.ts"() {
-    "use strict";
-  }
-});
-
-// src/core/navigators/generators/index.ts
-var generators_exports = {};
-var init_generators = __esm({
-  "src/core/navigators/generators/index.ts"() {
-    "use strict";
-  }
-});
-
-// src/core/navigators/generators/types.ts
-var types_exports2 = {};
-var init_types2 = __esm({
-  "src/core/navigators/generators/types.ts"() {
-    "use strict";
-  }
-});
-
-// src/core/navigators/hardcodedOrder.ts
-var hardcodedOrder_exports = {};
-__export(hardcodedOrder_exports, {
-  default: () => HardcodedOrderNavigator
-});
-var HardcodedOrderNavigator;
-var init_hardcodedOrder = __esm({
-  "src/core/navigators/hardcodedOrder.ts"() {
+// src/core/navigators/generators/srs.ts
+import moment3 from "moment";
+var SRSNavigator;
+var init_srs = __esm({
+  "src/core/navigators/generators/srs.ts"() {
     "use strict";
     init_navigators();
     init_logger();
-    HardcodedOrderNavigator = class extends ContentNavigator {
-      /** Human-readable name for CardGenerator interface */
-      name;
-      orderedCardIds = [];
-      constructor(user, course, strategyData) {
-        super(user, course, strategyData);
-        this.name = strategyData.name || "Hardcoded Order";
-        if (strategyData.serializedData) {
-          try {
-            this.orderedCardIds = JSON.parse(strategyData.serializedData);
-          } catch (e) {
-            logger.error("Failed to parse serializedData for HardcodedOrderNavigator", e);
-          }
-        }
-      }
-      async getPendingReviews() {
-        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 = 99) {
-        const activeCardIds = (await this.user.getActiveCards()).map((c) => 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"
-          };
-        });
-      }
-      /**
-       * Get cards in hardcoded order with scores based on position.
-       *
-       * Earlier cards in the sequence get higher scores.
-       * Score formula: 1.0 - (position / totalCards) * 0.5
-       * This ensures scores range from 1.0 (first card) to 0.5+ (last card).
-       *
-       * This method supports both the legacy signature (limit only) and the
-       * CardGenerator interface signature (limit, context).
-       *
-       * @param limit - Maximum number of cards to return
-       * @param _context - Optional GeneratorContext (currently unused, but required for interface)
-       */
-      async getWeightedCards(limit, _context) {
-        const activeCardIds = (await this.user.getActiveCards()).map((c) => c.cardID);
-        const reviews = await this.getPendingReviews();
-        const newCardIds = this.orderedCardIds.filter((cardId) => !activeCardIds.includes(cardId));
-        const totalCards = newCardIds.length;
-        const scoredNew = newCardIds.slice(0, limit).map((cardId, index) => {
-          const position = index + 1;
-          const score = Math.max(0.5, 1 - index / totalCards * 0.5);
-          return {
-            cardId,
-            courseId: this.course.getCourseID(),
-            score,
-            provenance: [
-              {
-                strategy: "hardcodedOrder",
-                strategyName: this.strategyName || this.name,
-                strategyId: this.strategyId || "NAVIGATION_STRATEGY-hardcoded",
-                action: "generated",
-                score,
-                reason: `Position ${position} of ${totalCards} in fixed sequence, new card`
-              }
-            ]
-          };
-        });
-        const scoredReviews = reviews.map((r) => ({
-          cardId: r.cardID,
-          courseId: r.courseID,
-          score: 1,
-          provenance: [
-            {
-              strategy: "hardcodedOrder",
-              strategyName: this.strategyName || this.name,
-              strategyId: this.strategyId || "NAVIGATION_STRATEGY-hardcoded",
-              action: "generated",
-              score: 1,
-              reason: "Scheduled review, highest priority"
-            }
-          ]
-        }));
-        const all = [...scoredReviews, ...scoredNew];
-        all.sort((a, b) => b.score - a.score);
-        return all.slice(0, limit);
-      }
-    };
-  }
-});
-
-// src/core/navigators/hierarchyDefinition.ts
-var hierarchyDefinition_exports = {};
-__export(hierarchyDefinition_exports, {
-  default: () => HierarchyDefinitionNavigator
-});
-import { toCourseElo as toCourseElo4 } from "@vue-skuilder/common";
-var DEFAULT_MIN_COUNT, HierarchyDefinitionNavigator;
-var init_hierarchyDefinition = __esm({
-  "src/core/navigators/hierarchyDefinition.ts"() {
-    "use strict";
-    init_navigators();
-    DEFAULT_MIN_COUNT = 3;
-    HierarchyDefinitionNavigator = class extends ContentNavigator {
-      config;
-      _strategyData;
-      /** Human-readable name for CardFilter interface */
-      name;
-      constructor(user, course, _strategyData) {
-        super(user, course, _strategyData);
-        this._strategyData = _strategyData;
-        this.config = this.parseConfig(_strategyData.serializedData);
-        this.name = _strategyData.name || "Hierarchy Definition";
-      }
-      parseConfig(serializedData) {
-        try {
-          const parsed = JSON.parse(serializedData);
-          return {
-            prerequisites: parsed.prerequisites || {}
-          };
-        } catch {
-          return {
-            prerequisites: {}
-          };
-        }
-      }
-      /**
-       * Check if a specific prerequisite is satisfied
-       */
-      isPrerequisiteMet(prereq, userTagElo, userGlobalElo) {
-        if (!userTagElo) return false;
-        const minCount = prereq.masteryThreshold?.minCount ?? DEFAULT_MIN_COUNT;
-        if (userTagElo.count < minCount) return false;
-        if (prereq.masteryThreshold?.minElo !== void 0) {
-          return userTagElo.score >= prereq.masteryThreshold.minElo;
-        } else {
-          return userTagElo.score >= userGlobalElo;
-        }
-      }
-      /**
-       * Get the set of tags the user has mastered.
-       * A tag is "mastered" if it appears as a prerequisite somewhere and meets its threshold.
-       */
-      async getMasteredTags(context) {
-        const mastered = /* @__PURE__ */ new Set();
-        try {
-          const courseReg = await context.user.getCourseRegDoc(context.course.getCourseID());
-          const userElo = toCourseElo4(courseReg.elo);
-          for (const prereqs of Object.values(this.config.prerequisites)) {
-            for (const prereq of prereqs) {
-              const tagElo = userElo.tags[prereq.tag];
-              if (this.isPrerequisiteMet(prereq, tagElo, userElo.global.score)) {
-                mastered.add(prereq.tag);
-              }
-            }
-          }
-        } catch {
-        }
-        return mastered;
-      }
-      /**
-       * Get the set of tags that are unlocked (prerequisites met)
-       */
-      getUnlockedTags(masteredTags) {
-        const unlocked = /* @__PURE__ */ new Set();
-        for (const [tagId, prereqs] of Object.entries(this.config.prerequisites)) {
-          const allPrereqsMet = prereqs.every((prereq) => masteredTags.has(prereq.tag));
-          if (allPrereqsMet) {
-            unlocked.add(tagId);
-          }
-        }
-        return unlocked;
-      }
-      /**
-       * Check if a tag has prerequisites defined in config
-       */
-      hasPrerequisites(tagId) {
-        return tagId in this.config.prerequisites;
-      }
-      /**
-       * Check if a card is unlocked and generate reason.
-       */
-      async checkCardUnlock(cardId, course, unlockedTags, masteredTags) {
-        try {
-          const tagResponse = await course.getAppliedTags(cardId);
-          const cardTags = tagResponse.rows.map((row) => row.value?.name || row.key);
-          const lockedTags = cardTags.filter(
-            (tag) => this.hasPrerequisites(tag) && !unlockedTags.has(tag)
-          );
-          if (lockedTags.length === 0) {
-            const tagList = cardTags.length > 0 ? cardTags.join(", ") : "none";
-            return {
-              isUnlocked: true,
-              reason: `Prerequisites met, tags: ${tagList}`
-            };
-          }
-          const missingPrereqs = lockedTags.flatMap((tag) => {
-            const prereqs = this.config.prerequisites[tag] || [];
-            return prereqs.filter((p) => !masteredTags.has(p.tag)).map((p) => p.tag);
-          });
-          return {
-            isUnlocked: false,
-            reason: `Blocked: missing prerequisites ${missingPrereqs.join(", ")} for tags ${lockedTags.join(", ")}`
-          };
-        } catch {
-          return {
-            isUnlocked: true,
-            reason: "Prerequisites check skipped (tag lookup failed)"
-          };
-        }
-      }
-      /**
-       * CardFilter.transform implementation.
-       *
-       * Apply prerequisite gating to cards. Cards with locked tags receive score: 0.
-       */
-      async transform(cards, context) {
-        const masteredTags = await this.getMasteredTags(context);
-        const unlockedTags = this.getUnlockedTags(masteredTags);
-        const gated = [];
-        for (const card of cards) {
-          const { isUnlocked, reason } = await this.checkCardUnlock(
-            card.cardId,
-            context.course,
-            unlockedTags,
-            masteredTags
-          );
-          const finalScore = isUnlocked ? card.score : 0;
-          const action = isUnlocked ? "passed" : "penalized";
-          gated.push({
-            ...card,
-            score: finalScore,
-            provenance: [
-              ...card.provenance,
-              {
-                strategy: "hierarchyDefinition",
-                strategyName: this.strategyName || this.name,
-                strategyId: this.strategyId || "NAVIGATION_STRATEGY-hierarchy",
-                action,
-                score: finalScore,
-                reason
-              }
-            ]
-          });
-        }
-        return gated;
-      }
-      /**
-       * Legacy getWeightedCards - now throws as filters should not be used as generators.
-       *
-       * Use transform() via Pipeline instead.
-       */
-      async getWeightedCards(_limit) {
-        throw new Error(
-          "HierarchyDefinitionNavigator is a filter and should not be used as a generator. Use Pipeline with a generator and this filter via transform()."
-        );
-      }
-      // Legacy methods - stub implementations since filters don't generate cards
-      async getNewCards(_n) {
-        return [];
-      }
-      async getPendingReviews() {
-        return [];
-      }
-    };
-  }
-});
-
-// src/core/navigators/interferenceMitigator.ts
-var interferenceMitigator_exports = {};
-__export(interferenceMitigator_exports, {
-  default: () => InterferenceMitigatorNavigator
-});
-import { toCourseElo as toCourseElo5 } from "@vue-skuilder/common";
-var DEFAULT_MIN_COUNT2, DEFAULT_MIN_ELAPSED_DAYS, DEFAULT_INTERFERENCE_DECAY, InterferenceMitigatorNavigator;
-var init_interferenceMitigator = __esm({
-  "src/core/navigators/interferenceMitigator.ts"() {
-    "use strict";
-    init_navigators();
-    DEFAULT_MIN_COUNT2 = 10;
-    DEFAULT_MIN_ELAPSED_DAYS = 3;
-    DEFAULT_INTERFERENCE_DECAY = 0.8;
-    InterferenceMitigatorNavigator = class extends ContentNavigator {
-      config;
-      _strategyData;
-      /** Human-readable name for CardFilter interface */
-      name;
-      /** Precomputed map: tag -> set of { partner, decay } it interferes with */
-      interferenceMap;
-      constructor(user, course, _strategyData) {
-        super(user, course, _strategyData);
-        this._strategyData = _strategyData;
-        this.config = this.parseConfig(_strategyData.serializedData);
-        this.interferenceMap = this.buildInterferenceMap();
-        this.name = _strategyData.name || "Interference Mitigator";
-      }
-      parseConfig(serializedData) {
-        try {
-          const parsed = JSON.parse(serializedData);
-          let sets = parsed.interferenceSets || [];
-          if (sets.length > 0 && Array.isArray(sets[0])) {
-            sets = sets.map((tags) => ({ tags }));
-          }
-          return {
-            interferenceSets: sets,
-            maturityThreshold: {
-              minCount: parsed.maturityThreshold?.minCount ?? DEFAULT_MIN_COUNT2,
-              minElo: parsed.maturityThreshold?.minElo,
-              minElapsedDays: parsed.maturityThreshold?.minElapsedDays ?? DEFAULT_MIN_ELAPSED_DAYS
-            },
-            defaultDecay: parsed.defaultDecay ?? DEFAULT_INTERFERENCE_DECAY
-          };
-        } catch {
-          return {
-            interferenceSets: [],
-            maturityThreshold: {
-              minCount: DEFAULT_MIN_COUNT2,
-              minElapsedDays: DEFAULT_MIN_ELAPSED_DAYS
-            },
-            defaultDecay: DEFAULT_INTERFERENCE_DECAY
-          };
-        }
-      }
-      /**
-       * Build a map from each tag to its interference partners with decay coefficients.
-       * If tags A, B, C are in an interference group with decay 0.8, then:
-       * - A interferes with B (decay 0.8) and C (decay 0.8)
-       * - B interferes with A (decay 0.8) and C (decay 0.8)
-       * - etc.
-       */
-      buildInterferenceMap() {
-        const map = /* @__PURE__ */ new Map();
-        for (const group of this.config.interferenceSets) {
-          const decay = group.decay ?? this.config.defaultDecay ?? DEFAULT_INTERFERENCE_DECAY;
-          for (const tag of group.tags) {
-            if (!map.has(tag)) {
-              map.set(tag, []);
-            }
-            const partners = map.get(tag);
-            for (const other of group.tags) {
-              if (other !== tag) {
-                const existing = partners.find((p) => p.partner === other);
-                if (existing) {
-                  existing.decay = Math.max(existing.decay, decay);
-                } else {
-                  partners.push({ partner: other, decay });
-                }
-              }
-            }
-          }
-        }
-        return map;
-      }
-      /**
-       * Get the set of tags that are currently immature for this user.
-       * A tag is immature if the user has interacted with it but hasn't
-       * reached the maturity threshold.
-       */
-      async getImmatureTags(context) {
-        const immature = /* @__PURE__ */ new Set();
-        try {
-          const courseReg = await context.user.getCourseRegDoc(context.course.getCourseID());
-          const userElo = toCourseElo5(courseReg.elo);
-          const minCount = this.config.maturityThreshold?.minCount ?? DEFAULT_MIN_COUNT2;
-          const minElo = this.config.maturityThreshold?.minElo;
-          const minElapsedDays = this.config.maturityThreshold?.minElapsedDays ?? DEFAULT_MIN_ELAPSED_DAYS;
-          const minCountForElapsed = minElapsedDays * 2;
-          for (const [tagId, tagElo] of Object.entries(userElo.tags)) {
-            if (tagElo.count === 0) continue;
-            const belowCount = tagElo.count < minCount;
-            const belowElo = minElo !== void 0 && tagElo.score < minElo;
-            const belowElapsed = tagElo.count < minCountForElapsed;
-            if (belowCount || belowElo || belowElapsed) {
-              immature.add(tagId);
-            }
-          }
-        } catch {
-        }
-        return immature;
-      }
-      /**
-       * Get all tags that interfere with any immature tag, along with their decay coefficients.
-       * These are the tags we want to avoid introducing.
-       */
-      getTagsToAvoid(immatureTags) {
-        const avoid = /* @__PURE__ */ new Map();
-        for (const immatureTag of immatureTags) {
-          const partners = this.interferenceMap.get(immatureTag);
-          if (partners) {
-            for (const { partner, decay } of partners) {
-              if (!immatureTags.has(partner)) {
-                const existing = avoid.get(partner) ?? 0;
-                avoid.set(partner, Math.max(existing, decay));
-              }
-            }
-          }
-        }
-        return avoid;
-      }
-      /**
-       * Get tags for a single card
-       */
-      async getCardTags(cardId, course) {
-        try {
-          const tagResponse = await course.getAppliedTags(cardId);
-          return tagResponse.rows.map((row) => row.value?.name || row.key).filter(Boolean);
-        } catch {
-          return [];
-        }
-      }
-      /**
-       * Compute interference score reduction for a card.
-       * Returns: { multiplier, interfering tags, reason }
-       */
-      computeInterferenceEffect(cardTags, tagsToAvoid, immatureTags) {
-        if (tagsToAvoid.size === 0) {
-          return {
-            multiplier: 1,
-            interferingTags: [],
-            reason: "No interference detected"
-          };
-        }
-        let multiplier = 1;
-        const interferingTags = [];
-        for (const tag of cardTags) {
-          const decay = tagsToAvoid.get(tag);
-          if (decay !== void 0) {
-            interferingTags.push(tag);
-            multiplier *= 1 - decay;
-          }
-        }
-        if (interferingTags.length === 0) {
-          return {
-            multiplier: 1,
-            interferingTags: [],
-            reason: "No interference detected"
-          };
-        }
-        const causingTags = /* @__PURE__ */ new Set();
-        for (const tag of interferingTags) {
-          for (const immatureTag of immatureTags) {
-            const partners = this.interferenceMap.get(immatureTag);
-            if (partners?.some((p) => p.partner === tag)) {
-              causingTags.add(immatureTag);
-            }
-          }
-        }
-        const reason = `Interferes with immature tags ${Array.from(causingTags).join(", ")} (tags: ${interferingTags.join(", ")}, multiplier: ${multiplier.toFixed(2)})`;
-        return { multiplier, interferingTags, reason };
-      }
-      /**
-       * CardFilter.transform implementation.
-       *
-       * Apply interference-aware scoring. Cards with tags that interfere with
-       * immature learnings get reduced scores.
-       */
-      async transform(cards, context) {
-        const immatureTags = await this.getImmatureTags(context);
-        const tagsToAvoid = this.getTagsToAvoid(immatureTags);
-        const adjusted = [];
-        for (const card of cards) {
-          const cardTags = await this.getCardTags(card.cardId, context.course);
-          const { multiplier, reason } = this.computeInterferenceEffect(
-            cardTags,
-            tagsToAvoid,
-            immatureTags
-          );
-          const finalScore = card.score * multiplier;
-          const action = multiplier < 1 ? "penalized" : multiplier > 1 ? "boosted" : "passed";
-          adjusted.push({
-            ...card,
-            score: finalScore,
-            provenance: [
-              ...card.provenance,
-              {
-                strategy: "interferenceMitigator",
-                strategyName: this.strategyName || this.name,
-                strategyId: this.strategyId || "NAVIGATION_STRATEGY-interference",
-                action,
-                score: finalScore,
-                reason
-              }
-            ]
-          });
-        }
-        return adjusted;
-      }
-      /**
-       * Legacy getWeightedCards - now throws as filters should not be used as generators.
-       *
-       * Use transform() via Pipeline instead.
-       */
-      async getWeightedCards(_limit) {
-        throw new Error(
-          "InterferenceMitigatorNavigator is a filter and should not be used as a generator. Use Pipeline with a generator and this filter via transform()."
-        );
-      }
-      // Legacy methods - stub implementations since filters don't generate cards
-      async getNewCards(_n) {
-        return [];
-      }
-      async getPendingReviews() {
-        return [];
-      }
-    };
-  }
-});
-
-// src/core/navigators/relativePriority.ts
-var relativePriority_exports = {};
-__export(relativePriority_exports, {
-  default: () => RelativePriorityNavigator
-});
-var DEFAULT_PRIORITY, DEFAULT_PRIORITY_INFLUENCE, DEFAULT_COMBINE_MODE, RelativePriorityNavigator;
-var init_relativePriority = __esm({
-  "src/core/navigators/relativePriority.ts"() {
-    "use strict";
-    init_navigators();
-    DEFAULT_PRIORITY = 0.5;
-    DEFAULT_PRIORITY_INFLUENCE = 0.5;
-    DEFAULT_COMBINE_MODE = "max";
-    RelativePriorityNavigator = class extends ContentNavigator {
-      config;
-      _strategyData;
-      /** Human-readable name for CardFilter interface */
-      name;
-      constructor(user, course, _strategyData) {
-        super(user, course, _strategyData);
-        this._strategyData = _strategyData;
-        this.config = this.parseConfig(_strategyData.serializedData);
-        this.name = _strategyData.name || "Relative Priority";
-      }
-      parseConfig(serializedData) {
-        try {
-          const parsed = JSON.parse(serializedData);
-          return {
-            tagPriorities: parsed.tagPriorities || {},
-            defaultPriority: parsed.defaultPriority ?? DEFAULT_PRIORITY,
-            combineMode: parsed.combineMode ?? DEFAULT_COMBINE_MODE,
-            priorityInfluence: parsed.priorityInfluence ?? DEFAULT_PRIORITY_INFLUENCE
-          };
-        } catch {
-          return {
-            tagPriorities: {},
-            defaultPriority: DEFAULT_PRIORITY,
-            combineMode: DEFAULT_COMBINE_MODE,
-            priorityInfluence: DEFAULT_PRIORITY_INFLUENCE
-          };
-        }
-      }
-      /**
-       * Look up the priority for a tag.
-       */
-      getTagPriority(tagId) {
-        return this.config.tagPriorities[tagId] ?? this.config.defaultPriority ?? DEFAULT_PRIORITY;
-      }
-      /**
-       * Compute combined priority for a card based on its tags.
-       */
-      computeCardPriority(cardTags) {
-        if (cardTags.length === 0) {
-          return this.config.defaultPriority ?? DEFAULT_PRIORITY;
-        }
-        const priorities = cardTags.map((tag) => this.getTagPriority(tag));
-        switch (this.config.combineMode) {
-          case "max":
-            return Math.max(...priorities);
-          case "min":
-            return Math.min(...priorities);
-          case "average":
-            return priorities.reduce((sum, p) => sum + p, 0) / priorities.length;
-          default:
-            return Math.max(...priorities);
-        }
-      }
-      /**
-       * Compute boost factor based on priority.
-       *
-       * The formula: 1 + (priority - 0.5) * priorityInfluence
-       *
-       * This creates a multiplier centered around 1.0:
-       * - Priority 1.0 with influence 0.5 → 1.25 (25% boost)
-       * - Priority 0.5 with any influence → 1.00 (neutral)
-       * - Priority 0.0 with influence 0.5 → 0.75 (25% reduction)
-       */
-      computeBoostFactor(priority) {
-        const influence = this.config.priorityInfluence ?? DEFAULT_PRIORITY_INFLUENCE;
-        return 1 + (priority - 0.5) * influence;
-      }
-      /**
-       * Build human-readable reason for priority adjustment.
-       */
-      buildPriorityReason(cardTags, priority, boostFactor, finalScore) {
-        if (cardTags.length === 0) {
-          return `No tags, neutral priority (${priority.toFixed(2)})`;
-        }
-        const tagList = cardTags.slice(0, 3).join(", ");
-        const more = cardTags.length > 3 ? ` (+${cardTags.length - 3} more)` : "";
-        if (boostFactor === 1) {
-          return `Neutral priority (${priority.toFixed(2)}) for tags: ${tagList}${more}`;
-        } else if (boostFactor > 1) {
-          return `High-priority tags: ${tagList}${more} (priority ${priority.toFixed(2)} \u2192 boost ${boostFactor.toFixed(2)}x \u2192 ${finalScore.toFixed(2)})`;
-        } else {
-          return `Low-priority tags: ${tagList}${more} (priority ${priority.toFixed(2)} \u2192 reduce ${boostFactor.toFixed(2)}x \u2192 ${finalScore.toFixed(2)})`;
-        }
-      }
-      /**
-       * Get tags for a single card.
-       */
-      async getCardTags(cardId, course) {
-        try {
-          const tagResponse = await course.getAppliedTags(cardId);
-          return tagResponse.rows.map((r) => r.doc?.name).filter((x) => !!x);
-        } catch {
-          return [];
-        }
-      }
-      /**
-       * CardFilter.transform implementation.
-       *
-       * Apply priority-adjusted scoring. Cards with high-priority tags get boosted,
-       * cards with low-priority tags get reduced scores.
-       */
-      async transform(cards, context) {
-        const adjusted = await Promise.all(
-          cards.map(async (card) => {
-            const cardTags = await this.getCardTags(card.cardId, context.course);
-            const priority = this.computeCardPriority(cardTags);
-            const boostFactor = this.computeBoostFactor(priority);
-            const finalScore = Math.max(0, Math.min(1, card.score * boostFactor));
-            const action = boostFactor > 1 ? "boosted" : boostFactor < 1 ? "penalized" : "passed";
-            const reason = this.buildPriorityReason(cardTags, priority, boostFactor, finalScore);
-            return {
-              ...card,
-              score: finalScore,
-              provenance: [
-                ...card.provenance,
-                {
-                  strategy: "relativePriority",
-                  strategyName: this.strategyName || this.name,
-                  strategyId: this.strategyId || "NAVIGATION_STRATEGY-priority",
-                  action,
-                  score: finalScore,
-                  reason
-                }
-              ]
-            };
-          })
-        );
-        return adjusted;
-      }
-      /**
-       * Legacy getWeightedCards - now throws as filters should not be used as generators.
-       *
-       * Use transform() via Pipeline instead.
-       */
-      async getWeightedCards(_limit) {
-        throw new Error(
-          "RelativePriorityNavigator is a filter and should not be used as a generator. Use Pipeline with a generator and this filter via transform()."
-        );
-      }
-      // Legacy methods - stub implementations since filters don't generate cards
-      async getNewCards(_n) {
-        return [];
-      }
-      async getPendingReviews() {
-        return [];
-      }
-    };
-  }
-});
-
-// src/core/navigators/srs.ts
-var srs_exports = {};
-__export(srs_exports, {
-  default: () => SRSNavigator
-});
-import moment3 from "moment";
-var SRSNavigator;
-var init_srs = __esm({
-  "src/core/navigators/srs.ts"() {
-    "use strict";
-    init_navigators();
     SRSNavigator = class extends ContentNavigator {
       /** Human-readable name for CardGenerator interface */
       name;
@@ -2310,6 +1551,7 @@ var init_srs = __esm({
             cardId: review.cardId,
             courseId: review.courseId,
             score,
+            reviewID: review._id,
             provenance: [
               {
                 strategy: "srs",
@@ -2322,6 +1564,7 @@ var init_srs = __esm({
             ]
           };
         });
+        logger.debug(`[srsNav] got ${scored.length} weighted cards`);
         return scored.sort((a, b) => b.score - a.score).slice(0, limit);
       }
       /**
@@ -2353,235 +1596,102 @@ var init_srs = __esm({
         const reason = `${Math.round(hoursOverdue)}h overdue (interval: ${Math.round(intervalHours)}h, relative: ${relativeOverdue.toFixed(2)}), recency: ${recencyFactor.toFixed(2)}, review`;
         return { score, reason };
       }
-      /**
-       * Get pending reviews in legacy format.
-       *
-       * Returns all pending reviews for the course, enriched with session item fields.
-       */
-      async getPendingReviews() {
-        if (!this.user || !this.course) {
-          throw new Error("SRSNavigator requires user and course to be set");
-        }
-        const reviews = await this.user.getPendingReviews(this.course.getCourseID());
-        return reviews.map((r) => ({
-          ...r,
-          contentSourceType: "course",
-          contentSourceID: this.course.getCourseID(),
-          cardID: r.cardId,
-          courseID: r.courseId,
-          qualifiedID: `${r.courseId}-${r.cardId}`,
-          reviewID: r._id,
-          status: "review"
-        }));
-      }
-      /**
-       * SRS does not generate new cards.
-       * Use ELONavigator or another generator for new cards.
-       */
-      async getNewCards(_n) {
-        return [];
-      }
     };
   }
 });
 
-// import("./**/*") in src/core/navigators/index.ts
-var globImport;
-var init_ = __esm({
-  'import("./**/*") in src/core/navigators/index.ts'() {
-    globImport = __glob({
-      "./CompositeGenerator.ts": () => Promise.resolve().then(() => (init_CompositeGenerator(), CompositeGenerator_exports)),
-      "./Pipeline.ts": () => Promise.resolve().then(() => (init_Pipeline(), Pipeline_exports)),
-      "./PipelineAssembler.ts": () => Promise.resolve().then(() => (init_PipelineAssembler(), PipelineAssembler_exports)),
-      "./elo.ts": () => Promise.resolve().then(() => (init_elo(), elo_exports)),
-      "./filters/eloDistance.ts": () => Promise.resolve().then(() => (init_eloDistance(), eloDistance_exports)),
-      "./filters/index.ts": () => Promise.resolve().then(() => (init_filters(), filters_exports)),
-      "./filters/types.ts": () => Promise.resolve().then(() => (init_types(), types_exports)),
-      "./generators/index.ts": () => Promise.resolve().then(() => (init_generators(), generators_exports)),
-      "./generators/types.ts": () => Promise.resolve().then(() => (init_types2(), types_exports2)),
-      "./hardcodedOrder.ts": () => Promise.resolve().then(() => (init_hardcodedOrder(), hardcodedOrder_exports)),
-      "./hierarchyDefinition.ts": () => Promise.resolve().then(() => (init_hierarchyDefinition(), hierarchyDefinition_exports)),
-      "./index.ts": () => Promise.resolve().then(() => (init_navigators(), navigators_exports)),
-      "./interferenceMitigator.ts": () => Promise.resolve().then(() => (init_interferenceMitigator(), interferenceMitigator_exports)),
-      "./relativePriority.ts": () => Promise.resolve().then(() => (init_relativePriority(), relativePriority_exports)),
-      "./srs.ts": () => Promise.resolve().then(() => (init_srs(), srs_exports))
-    });
-  }
-});
-
-// src/core/navigators/index.ts
-var navigators_exports = {};
-__export(navigators_exports, {
-  ContentNavigator: () => ContentNavigator,
-  NavigatorRole: () => NavigatorRole,
-  NavigatorRoles: () => NavigatorRoles,
-  Navigators: () => Navigators,
-  getCardOrigin: () => getCardOrigin,
-  isFilter: () => isFilter,
-  isGenerator: () => isGenerator
-});
-function getCardOrigin(card) {
-  if (card.provenance.length === 0) {
-    throw new Error("Card has no provenance - cannot determine origin");
-  }
-  const firstEntry = card.provenance[0];
-  const reason = firstEntry.reason.toLowerCase();
-  if (reason.includes("failed")) {
-    return "failed";
-  }
-  if (reason.includes("review")) {
-    return "review";
-  }
-  return "new";
-}
-function isGenerator(impl) {
-  return NavigatorRoles[impl] === "generator" /* GENERATOR */;
-}
-function isFilter(impl) {
-  return NavigatorRoles[impl] === "filter" /* FILTER */;
+// src/core/navigators/filters/eloDistance.ts
+function computeMultiplier(distance, halfLife, minMultiplier, maxMultiplier) {
+  const normalizedDistance = distance / halfLife;
+  const decay = Math.exp(-(normalizedDistance * normalizedDistance));
+  return minMultiplier + (maxMultiplier - minMultiplier) * decay;
 }
-var Navigators, NavigatorRole, NavigatorRoles, ContentNavigator;
-var init_navigators = __esm({
-  "src/core/navigators/index.ts"() {
-    "use strict";
-    init_logger();
-    init_();
-    Navigators = /* @__PURE__ */ ((Navigators2) => {
-      Navigators2["ELO"] = "elo";
-      Navigators2["SRS"] = "srs";
-      Navigators2["HARDCODED"] = "hardcodedOrder";
-      Navigators2["HIERARCHY"] = "hierarchyDefinition";
-      Navigators2["INTERFERENCE"] = "interferenceMitigator";
-      Navigators2["RELATIVE_PRIORITY"] = "relativePriority";
-      return Navigators2;
-    })(Navigators || {});
-    NavigatorRole = /* @__PURE__ */ ((NavigatorRole2) => {
-      NavigatorRole2["GENERATOR"] = "generator";
-      NavigatorRole2["FILTER"] = "filter";
-      return NavigatorRole2;
-    })(NavigatorRole || {});
-    NavigatorRoles = {
-      ["elo" /* ELO */]: "generator" /* GENERATOR */,
-      ["srs" /* SRS */]: "generator" /* GENERATOR */,
-      ["hardcodedOrder" /* HARDCODED */]: "generator" /* GENERATOR */,
-      ["hierarchyDefinition" /* HIERARCHY */]: "filter" /* FILTER */,
-      ["interferenceMitigator" /* INTERFERENCE */]: "filter" /* FILTER */,
-      ["relativePriority" /* RELATIVE_PRIORITY */]: "filter" /* FILTER */
-    };
-    ContentNavigator = class {
-      /** User interface for this navigation session */
-      user;
-      /** Course interface for this navigation session */
-      course;
-      /** Human-readable name for this strategy instance (from ContentNavigationStrategyData.name) */
-      strategyName;
-      /** Unique document ID for this strategy instance (from ContentNavigationStrategyData._id) */
-      strategyId;
-      /**
-       * Constructor for standard navigators.
-       * Call this from subclass constructors to initialize common fields.
-       *
-       * Note: CompositeGenerator doesn't use this pattern and should call super() without args.
-       */
-      constructor(user, course, strategyData) {
-        if (user && course && strategyData) {
-          this.user = user;
-          this.course = course;
-          this.strategyName = strategyData.name;
-          this.strategyId = strategyData._id;
-        }
-      }
-      /**
-       * Factory method to create navigator instances dynamically.
-       *
-       * @param user - User interface
-       * @param course - Course interface
-       * @param strategyData - Strategy configuration document
-       * @returns the runtime object used to steer a study session.
-       */
-      static async create(user, course, strategyData) {
-        const implementingClass = strategyData.implementingClass;
-        let NavigatorImpl;
-        const variations = [".ts", ".js", ""];
-        for (const ext of variations) {
-          try {
-            const module = await globImport(`./${implementingClass}${ext}`);
-            NavigatorImpl = module.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);
-      }
-      /**
-       * Get cards with suitability scores and provenance trails.
-       *
-       * **This is the PRIMARY API for navigation strategies.**
-       *
-       * Returns cards ranked by suitability score (0-1). Higher scores indicate
-       * better candidates for presentation. Each card includes a provenance trail
-       * documenting how strategies contributed to the final score.
-       *
-       * ## For Generators
-       * Override this method to generate candidates and compute scores based on
-       * your strategy's logic (e.g., ELO proximity, review urgency). Create the
-       * initial provenance entry with action='generated'.
-       *
-       * ## Default Implementation
-       * The base class provides a backward-compatible default that:
-       * 1. Calls legacy getNewCards() and getPendingReviews()
-       * 2. Assigns score=1.0 to all cards
-       * 3. Creates minimal provenance from legacy methods
-       * 4. Returns combined results up to limit
-       *
-       * This allows existing strategies to work without modification while
-       * new strategies can override with proper scoring and provenance.
-       *
-       * @param limit - Maximum cards to return
-       * @returns Cards sorted by score descending, with provenance trails
-       */
-      async getWeightedCards(limit) {
-        const newCards = await this.getNewCards(limit);
-        const reviews = await this.getPendingReviews();
-        const weighted = [
-          ...newCards.map((c) => ({
-            cardId: c.cardID,
-            courseId: c.courseID,
-            score: 1,
-            provenance: [
-              {
-                strategy: "legacy",
-                strategyName: this.strategyName || "Legacy API",
-                strategyId: this.strategyId || "legacy-fallback",
-                action: "generated",
-                score: 1,
-                reason: "Generated via legacy getNewCards(), new card"
-              }
-            ]
-          })),
-          ...reviews.map((r) => ({
-            cardId: r.cardID,
-            courseId: r.courseID,
-            score: 1,
-            provenance: [
-              {
-                strategy: "legacy",
-                strategyName: this.strategyName || "Legacy API",
-                strategyId: this.strategyId || "legacy-fallback",
-                action: "generated",
-                score: 1,
-                reason: "Generated via legacy getPendingReviews(), review"
-              }
-            ]
-          }))
-        ];
-        return weighted.slice(0, limit);
-      }
-    };
+function createEloDistanceFilter(config) {
+  const halfLife = config?.halfLife ?? DEFAULT_HALF_LIFE;
+  const minMultiplier = config?.minMultiplier ?? DEFAULT_MIN_MULTIPLIER;
+  const maxMultiplier = config?.maxMultiplier ?? DEFAULT_MAX_MULTIPLIER;
+  return {
+    name: "ELO Distance Filter",
+    async transform(cards, context) {
+      const { course, userElo } = context;
+      const cardIds = cards.map((c) => c.cardId);
+      const cardElos = await course.getCardEloData(cardIds);
+      return cards.map((card, i) => {
+        const cardElo = cardElos[i]?.global?.score ?? 1e3;
+        const distance = Math.abs(cardElo - userElo);
+        const multiplier = computeMultiplier(distance, halfLife, minMultiplier, maxMultiplier);
+        const newScore = card.score * multiplier;
+        const action = multiplier < maxMultiplier - 0.01 ? "penalized" : "passed";
+        return {
+          ...card,
+          score: newScore,
+          provenance: [
+            ...card.provenance,
+            {
+              strategy: "eloDistance",
+              strategyName: "ELO Distance Filter",
+              strategyId: "ELO_DISTANCE_FILTER",
+              action,
+              score: newScore,
+              reason: `ELO distance ${Math.round(distance)} (card: ${Math.round(cardElo)}, user: ${Math.round(userElo)}) \u2192 ${multiplier.toFixed(2)}x`
+            }
+          ]
+        };
+      });
+    }
+  };
+}
+var DEFAULT_HALF_LIFE, DEFAULT_MIN_MULTIPLIER, DEFAULT_MAX_MULTIPLIER;
+var init_eloDistance = __esm({
+  "src/core/navigators/filters/eloDistance.ts"() {
+    "use strict";
+    DEFAULT_HALF_LIFE = 200;
+    DEFAULT_MIN_MULTIPLIER = 0.3;
+    DEFAULT_MAX_MULTIPLIER = 1;
+  }
+});
+
+// src/core/navigators/defaults.ts
+function createDefaultEloStrategy(courseId) {
+  return {
+    _id: "NAVIGATION_STRATEGY-ELO-default",
+    docType: "NAVIGATION_STRATEGY" /* NAVIGATION_STRATEGY */,
+    name: "ELO (default)",
+    description: "Default ELO-based navigation strategy for new cards",
+    implementingClass: "elo" /* ELO */,
+    course: courseId,
+    serializedData: ""
+  };
+}
+function createDefaultSrsStrategy(courseId) {
+  return {
+    _id: "NAVIGATION_STRATEGY-SRS-default",
+    docType: "NAVIGATION_STRATEGY" /* NAVIGATION_STRATEGY */,
+    name: "SRS (default)",
+    description: "Default SRS-based navigation strategy for reviews",
+    implementingClass: "srs" /* SRS */,
+    course: courseId,
+    serializedData: ""
+  };
+}
+function createDefaultPipeline(user, course) {
+  const courseId = course.getCourseID();
+  const eloNavigator = new ELONavigator(user, course, createDefaultEloStrategy(courseId));
+  const srsNavigator = new SRSNavigator(user, course, createDefaultSrsStrategy(courseId));
+  const compositeGenerator = new CompositeGenerator([eloNavigator, srsNavigator]);
+  const eloDistanceFilter = createEloDistanceFilter();
+  return new Pipeline(compositeGenerator, [eloDistanceFilter], user, course);
+}
+var init_defaults = __esm({
+  "src/core/navigators/defaults.ts"() {
+    "use strict";
+    init_navigators();
+    init_Pipeline();
+    init_CompositeGenerator();
+    init_elo();
+    init_srs();
+    init_eloDistance();
+    init_types_legacy();
   }
 });
 
@@ -2590,7 +1700,7 @@ import {
   EloToNumber,
   Status,
   blankCourseElo as blankCourseElo2,
-  toCourseElo as toCourseElo6
+  toCourseElo as toCourseElo4
 } from "@vue-skuilder/common";
 function randIntWeightedTowardZero(n) {
   return Math.floor(Math.random() * Math.random() * Math.random() * n);
@@ -2679,12 +1789,8 @@ var init_courseDB = __esm({
     init_courseAPI();
     init_courseLookupDB();
     init_navigators();
-    init_Pipeline();
     init_PipelineAssembler();
-    init_CompositeGenerator();
-    init_elo();
-    init_srs();
-    init_eloDistance();
+    init_defaults();
     CoursesDB = class {
       _courseIDs;
       constructor(courseIDs) {
@@ -2796,7 +1902,7 @@ var init_courseDB = __esm({
         docs.rows.forEach((r) => {
           if (isSuccessRow(r)) {
             if (r.doc && r.doc.elo) {
-              ret.push(toCourseElo6(r.doc.elo));
+              ret.push(toCourseElo4(r.doc.elo));
             } else {
               logger.warn("no elo data for card: " + r.id);
               ret.push(blankCourseElo2());
@@ -2865,15 +1971,6 @@ var init_courseDB = __esm({
             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) {
@@ -2958,6 +2055,28 @@ ${above.rows.map((r) => `	${r.id}-${r.key}
           throw new Error(`Failed to find tags for card ${this.id}-${cardId}`);
         }
       }
+      async getAppliedTagsBatch(cardIds) {
+        if (cardIds.length === 0) {
+          return /* @__PURE__ */ new Map();
+        }
+        const db = getCourseDB2(this.id);
+        const result = await db.query("getTags", {
+          keys: cardIds,
+          include_docs: false
+        });
+        const tagsByCard = /* @__PURE__ */ new Map();
+        for (const cardId of cardIds) {
+          tagsByCard.set(cardId, []);
+        }
+        for (const row of result.rows) {
+          const cardId = row.key;
+          const tagName = row.value?.name;
+          if (tagName && tagsByCard.has(cardId)) {
+            tagsByCard.get(cardId).push(tagName);
+          }
+        }
+        return tagsByCard;
+      }
       async addTagToCard(cardId, tagId, updateELO) {
         return await addTagToCard(
           this.id,
@@ -3085,7 +2204,7 @@ ${above.rows.map((r) => `	${r.id}-${r.key}
             logger.debug(
               "[courseDB] No strategy documents found, using default Pipeline(Composite(ELO, SRS), [eloDistanceFilter])"
             );
-            return this.createDefaultPipeline(user);
+            return createDefaultPipeline(user, this);
           }
           const assembler = new PipelineAssembler();
           const { pipeline, generatorStrategies, filterStrategies, warnings } = await assembler.assemble({
@@ -3098,7 +2217,7 @@ ${above.rows.map((r) => `	${r.id}-${r.key}
           }
           if (!pipeline) {
             logger.debug("[courseDB] Pipeline assembly failed, using default pipeline");
-            return this.createDefaultPipeline(user);
+            return createDefaultPipeline(user, this);
           }
           logger.debug(
             `[courseDB] Using assembled pipeline with ${generatorStrategies.length} generator(s) and ${filterStrategies.length} filter(s)`
@@ -3109,69 +2228,12 @@ ${above.rows.map((r) => `	${r.id}-${r.key}
           throw e;
         }
       }
-      makeDefaultEloStrategy() {
-        return {
-          _id: "NAVIGATION_STRATEGY-ELO-default",
-          docType: "NAVIGATION_STRATEGY" /* NAVIGATION_STRATEGY */,
-          name: "ELO (default)",
-          description: "Default ELO-based navigation strategy for new cards",
-          implementingClass: "elo" /* ELO */,
-          course: this.id,
-          serializedData: ""
-        };
-      }
-      makeDefaultSrsStrategy() {
-        return {
-          _id: "NAVIGATION_STRATEGY-SRS-default",
-          docType: "NAVIGATION_STRATEGY" /* NAVIGATION_STRATEGY */,
-          name: "SRS (default)",
-          description: "Default SRS-based navigation strategy for reviews",
-          implementingClass: "srs" /* SRS */,
-          course: this.id,
-          serializedData: ""
-        };
-      }
-      /**
-       * Creates the default navigation pipeline for courses with no configured strategies.
-       *
-       * Default: Pipeline(Composite(ELO, SRS), [eloDistanceFilter])
-       * - ELO generator: scores new cards by skill proximity
-       * - SRS generator: scores reviews by overdueness and interval recency
-       * - ELO distance filter: penalizes cards far from user's current level
-       */
-      createDefaultPipeline(user) {
-        const eloNavigator = new ELONavigator(user, this, this.makeDefaultEloStrategy());
-        const srsNavigator = new SRSNavigator(user, this, this.makeDefaultSrsStrategy());
-        const compositeGenerator = new CompositeGenerator([eloNavigator, srsNavigator]);
-        const eloDistanceFilter = createEloDistanceFilter();
-        return new Pipeline(compositeGenerator, [eloDistanceFilter], user, this);
-      }
       ////////////////////////////////////
       // END NavigationStrategyManager implementation
       ////////////////////////////////////
       ////////////////////////////////////
       // StudyContentSource implementation
       ////////////////////////////////////
-      async getNewCards(limit = 99) {
-        const u = await this._getCurrentUser();
-        try {
-          const navigator = await this.createNavigator(u);
-          return navigator.getNewCards(limit);
-        } catch (e) {
-          logger.error(`[courseDB] Error in getNewCards: ${e}`);
-          throw e;
-        }
-      }
-      async getPendingReviews() {
-        const u = await this._getCurrentUser();
-        try {
-          const navigator = await this.createNavigator(u);
-          return navigator.getPendingReviews();
-        } catch (e) {
-          logger.error(`[courseDB] Error in getPendingReviews: ${e}`);
-          throw e;
-        }
-      }
       /**
        * Get cards with suitability scores for presentation.
        *
@@ -3411,79 +2473,27 @@ var init_classroomDB2 = __esm({
       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 = moment4.utc();
-        const assigned = await this.getAssignedContent();
-        const due = assigned.filter((c) => now.isAfter(moment4.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.courseID}-${c.cardID}`)}`
-        );
-        return ret.filter((c) => {
-          if (activeCards.some((ac) => c.cardID === ac.cardID)) {
-            return false;
-          } else {
-            return true;
-          }
-        });
-      }
       /**
        * Get cards with suitability scores for presentation.
        *
-       * This implementation wraps the legacy getNewCards/getPendingReviews methods,
-       * assigning score=1.0 to all cards. StudentClassroomDB does not currently
-       * support pluggable navigation strategies.
+       * Gathers new cards from assigned content (courses, tags, cards) and
+       * pending reviews scheduled for this classroom. Assigns score=1.0 to all.
        *
        * @param limit - Maximum number of cards to return
        * @returns Cards sorted by score descending (all scores = 1.0)
        */
       async getWeightedCards(limit) {
-        const [newCards, reviews] = await Promise.all([this.getNewCards(), this.getPendingReviews()]);
-        const weighted = [
-          ...newCards.map((c) => ({
-            cardId: c.cardID,
-            courseId: c.courseID,
+        const weighted = [];
+        const allUserReviews = await this._user.getPendingReviews();
+        const classroomReviews = allUserReviews.filter(
+          (r) => r.scheduledFor === "classroom" && r.schedulingAgentId === this._id
+        );
+        for (const r of classroomReviews) {
+          weighted.push({
+            cardId: r.cardId,
+            courseId: r.courseId,
             score: 1,
+            reviewID: r._id,
             provenance: [
               {
                 strategy: "classroom",
@@ -3491,27 +2501,84 @@ var init_classroomDB2 = __esm({
                 strategyId: "CLASSROOM",
                 action: "generated",
                 score: 1,
-                reason: "Classroom legacy getNewCards(), new card"
+                reason: "Classroom scheduled review"
               }
             ]
-          })),
-          ...reviews.map((r) => ({
-            cardId: r.cardID,
-            courseId: r.courseID,
-            score: 1,
-            provenance: [
-              {
-                strategy: "classroom",
-                strategyName: "Classroom",
-                strategyId: "CLASSROOM",
-                action: "generated",
-                score: 1,
-                reason: "Classroom legacy getPendingReviews(), review"
+          });
+        }
+        const activeCards = await this._user.getActiveCards();
+        const activeCardIds = new Set(activeCards.map((ac) => ac.cardID));
+        const now = moment4.utc();
+        const assigned = await this.getAssignedContent();
+        const due = assigned.filter((c) => now.isAfter(moment4.utc(c.activeOn, REVIEW_TIME_FORMAT2)));
+        logger.info(`[StudentClassroomDB] Due content: ${JSON.stringify(due)}`);
+        for (const content of due) {
+          if (content.type === "course") {
+            const db = new CourseDB(content.courseID, async () => this._user);
+            const courseCards = await db.getWeightedCards(limit);
+            for (const card of courseCards) {
+              if (!activeCardIds.has(card.cardId)) {
+                weighted.push({
+                  ...card,
+                  provenance: [
+                    ...card.provenance,
+                    {
+                      strategy: "classroom",
+                      strategyName: "Classroom",
+                      strategyId: "CLASSROOM",
+                      action: "passed",
+                      score: card.score,
+                      reason: `Assigned via classroom from course ${content.courseID}`
+                    }
+                  ]
+                });
               }
-            ]
-          }))
-        ];
-        return weighted.slice(0, limit);
+            }
+          } else if (content.type === "tag") {
+            const tagDoc = await getTag(content.courseID, content.tagID);
+            for (const cardId of tagDoc.taggedCards) {
+              if (!activeCardIds.has(cardId)) {
+                weighted.push({
+                  cardId,
+                  courseId: content.courseID,
+                  score: 1,
+                  provenance: [
+                    {
+                      strategy: "classroom",
+                      strategyName: "Classroom",
+                      strategyId: "CLASSROOM",
+                      action: "generated",
+                      score: 1,
+                      reason: `Classroom assigned tag: ${content.tagID}, new card`
+                    }
+                  ]
+                });
+              }
+            }
+          } else if (content.type === "card") {
+            if (!activeCardIds.has(content.cardID)) {
+              weighted.push({
+                cardId: content.cardID,
+                courseId: content.courseID,
+                score: 1,
+                provenance: [
+                  {
+                    strategy: "classroom",
+                    strategyName: "Classroom",
+                    strategyId: "CLASSROOM",
+                    action: "generated",
+                    score: 1,
+                    reason: "Classroom assigned card, new card"
+                  }
+                ]
+              });
+            }
+          }
+        }
+        logger.info(
+          `[StudentClassroomDB] New cards from classroom ${this._cfg.name}: ${weighted.length} total (reviews + new)`
+        );
+        return weighted.sort((a, b) => b.score - a.score).slice(0, limit);
       }
     };
     TeacherClassroomDB = class _TeacherClassroomDB extends ClassroomDBBase {
@@ -3659,8 +2726,7 @@ var init_adminDB2 = __esm({
             }
           }
         }
-        const dbs = await Promise.all(promisedCRDbs);
-        return dbs.map((db) => {
+        return promisedCRDbs.map((db) => {
           return {
             ...db.getConfig(),
             _id: db._id
@@ -3948,8 +3014,8 @@ import moment5 from "moment";
 import process2 from "process";
 function createPouchDBConfig() {
   const hasExplicitCredentials = ENV.COUCHDB_USERNAME && ENV.COUCHDB_PASSWORD;
-  const isNodeEnvironment2 = typeof window === "undefined";
-  if (hasExplicitCredentials && isNodeEnvironment2) {
+  const isNodeEnvironment = typeof window === "undefined";
+  if (hasExplicitCredentials && isNodeEnvironment) {
     return {
       fetch(url, opts = {}) {
         const basicAuth = btoa(`${ENV.COUCHDB_USERNAME}:${ENV.COUCHDB_PASSWORD}`);
@@ -4033,7 +3099,9 @@ import moment6 from "moment";
 function accomodateGuest() {
   logger.log("[funnel] accomodateGuest() called");
   if (typeof localStorage === "undefined") {
-    logger.log("[funnel] localStorage not available (Node.js environment), returning default guest");
+    logger.log(
+      "[funnel] localStorage not available (Node.js environment), returning default guest"
+    );
     return {
       username: GuestUsername + "nodejs-test",
       firstVisit: true
@@ -5011,6 +4079,55 @@ Currently logged-in as ${this._username}.`
       async updateUserElo(courseId, elo) {
         return updateUserElo(this._username, courseId, elo);
       }
+      async getStrategyState(courseId, strategyKey) {
+        const docId = buildStrategyStateId(courseId, strategyKey);
+        try {
+          const doc = await this.localDB.get(docId);
+          return doc.data;
+        } catch (e) {
+          const err = e;
+          if (err.status === 404) {
+            return null;
+          }
+          throw e;
+        }
+      }
+      async putStrategyState(courseId, strategyKey, data) {
+        const docId = buildStrategyStateId(courseId, strategyKey);
+        let existingRev;
+        try {
+          const existing = await this.localDB.get(docId);
+          existingRev = existing._rev;
+        } catch (e) {
+          const err = e;
+          if (err.status !== 404) {
+            throw e;
+          }
+        }
+        const doc = {
+          _id: docId,
+          _rev: existingRev,
+          docType: "STRATEGY_STATE" /* STRATEGY_STATE */,
+          courseId,
+          strategyKey,
+          data,
+          updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+        };
+        await this.localDB.put(doc);
+      }
+      async deleteStrategyState(courseId, strategyKey) {
+        const docId = buildStrategyStateId(courseId, strategyKey);
+        try {
+          const doc = await this.localDB.get(docId);
+          await this.localDB.remove(doc);
+        } catch (e) {
+          const err = e;
+          if (err.status === 404) {
+            return;
+          }
+          throw e;
+        }
+      }
     };
     userCoursesDoc = "CourseRegistrations";
     userClassroomsDoc = "ClassroomRegistrations";
@@ -5058,8 +4175,8 @@ var init_PouchDataLayerProvider = __esm({
       }
       async initialize() {
         if (this.initialized) return;
-        const isNodeEnvironment2 = typeof process !== "undefined" && process.versions != null && process.versions.node != null;
-        if (isNodeEnvironment2) {
+        const isNodeEnvironment = typeof process !== "undefined" && process.versions != null && process.versions.node != null;
+        if (isNodeEnvironment) {
           logger.info(
             "CouchDataLayerProvider: Running in Node.js environment, creating guest UserDB for testing."
           );
@@ -5121,11 +4238,11 @@ var init_StaticDataUnpacker = __esm({
     init_logger();
     init_core();
     pathUtils = {
-      isAbsolute: (path3) => {
-        if (/^[a-zA-Z]:[\\/]/.test(path3) || /^\\\\/.test(path3)) {
+      isAbsolute: (path2) => {
+        if (/^[a-zA-Z]:[\\/]/.test(path2) || /^\\\\/.test(path2)) {
           return true;
         }
-        if (path3.startsWith("/")) {
+        if (path2.startsWith("/")) {
           return true;
         }
         return false;
@@ -5172,6 +4289,36 @@ var init_StaticDataUnpacker = __esm({
         logger.error(`Document ${id} not found in chunk ${chunk.id}`);
         throw new Error(`Document ${id} not found in chunk ${chunk.id}`);
       }
+      /**
+       * Get all documents with IDs starting with a specific prefix.
+       *
+       * This method loads the relevant chunk(s) and returns all matching documents.
+       * Useful for querying documents by type (e.g., all NAVIGATION_STRATEGY documents).
+       *
+       * @param prefix - Document ID prefix to match (e.g., "NAVIGATION_STRATEGY")
+       * @returns Array of all documents with IDs starting with the prefix
+       */
+      async getAllDocumentsByPrefix(prefix) {
+        const relevantChunks = this.manifest.chunks.filter((chunk) => {
+          const prefixEnd = prefix + "\uFFF0";
+          return chunk.startKey <= prefixEnd && chunk.endKey >= prefix;
+        });
+        if (relevantChunks.length === 0) {
+          logger.debug(`[StaticDataUnpacker] No chunks found for prefix: ${prefix}`);
+          return [];
+        }
+        await Promise.all(relevantChunks.map((chunk) => this.loadChunk(chunk.id)));
+        const matchingDocs = [];
+        for (const [docId, doc] of this.documentCache.entries()) {
+          if (docId.startsWith(prefix)) {
+            matchingDocs.push(await this.hydrateAttachments(doc));
+          }
+        }
+        logger.debug(
+          `[StaticDataUnpacker] Found ${matchingDocs.length} documents with prefix: ${prefix}`
+        );
+        return matchingDocs;
+      }
       /**
        * Query cards by ELO score, returning card IDs sorted by ELO
        */
@@ -5208,7 +4355,14 @@ var init_StaticDataUnpacker = __esm({
        * Get all tag names mapped to their card arrays
        */
       async getTagsIndex() {
-        return await this.loadIndex("tags");
+        try {
+          return await this.loadIndex("tags");
+        } catch {
+          return {
+            byCard: {},
+            byTag: {}
+          };
+        }
       }
       getDocTypeFromId(id) {
         for (const docTypeKey in DocTypePrefixes) {
@@ -5499,8 +4653,9 @@ var init_courseDB2 = __esm({
   "src/impl/static/courseDB.ts"() {
     "use strict";
     init_types_legacy();
-    init_navigators();
     init_logger();
+    init_defaults();
+    init_PipelineAssembler();
     StaticCourseDB = class {
       constructor(courseId, unpacker, userDB, manifest) {
         this.courseId = courseId;
@@ -5579,21 +4734,6 @@ var init_courseDB2 = __esm({
       async updateCardElo(cardId, _elo) {
         return { ok: true, id: cardId, rev: "1-static" };
       }
-      async getNewCards(limit = 99) {
-        const activeCards = await this.userDB.getActiveCards();
-        return (await this.getCardsCenteredAtELO({ limit, elo: "user" }, (c) => {
-          if (activeCards.some((ac) => c.cardID === ac.cardID)) {
-            return false;
-          } else {
-            return true;
-          }
-        })).map((c) => {
-          return {
-            ...c,
-            status: "new"
-          };
-        });
-      }
       async getCardsCenteredAtELO(options, filter) {
         let targetElo = typeof options.elo === "number" ? options.elo : 1e3;
         if (options.elo === "user") {
@@ -5678,6 +4818,14 @@ var init_courseDB2 = __esm({
           };
         }
       }
+      async getAppliedTagsBatch(cardIds) {
+        const tagsIndex = await this.unpacker.getTagsIndex();
+        const tagsByCard = /* @__PURE__ */ new Map();
+        for (const cardId of cardIds) {
+          tagsByCard.set(cardId, tagsIndex.byCard[cardId] || []);
+        }
+        return tagsByCard;
+      }
       async addTagToCard(_cardId, _tagId) {
         throw new Error("Cannot modify tags in static mode");
       }
@@ -5771,19 +4919,23 @@ var init_courseDB2 = __esm({
         return [];
       }
       // Navigation Strategy Manager implementation
-      async getNavigationStrategy(_id) {
-        return {
-          _id: "NAVIGATION_STRATEGY-ELO",
-          docType: "NAVIGATION_STRATEGY" /* NAVIGATION_STRATEGY */,
-          name: "ELO",
-          description: "ELO-based navigation strategy",
-          implementingClass: "elo" /* ELO */,
-          course: this.courseId,
-          serializedData: ""
-        };
+      async getNavigationStrategy(id) {
+        try {
+          return await this.unpacker.getDocument(id);
+        } catch (error) {
+          logger.error(`[static/courseDB] Strategy ${id} not found: ${error}`);
+          throw error;
+        }
       }
       async getAllNavigationStrategies() {
-        return [await this.getNavigationStrategy("ELO")];
+        const prefix = DocTypePrefixes["NAVIGATION_STRATEGY" /* NAVIGATION_STRATEGY */];
+        try {
+          const docs = await this.unpacker.getAllDocumentsByPrefix(prefix);
+          return docs;
+        } catch (error) {
+          logger.warn(`[static/courseDB] Error loading navigation strategies: ${error}`);
+          return [];
+        }
       }
       async addNavigationStrategy(_data) {
         throw new Error("Cannot add navigation strategies in static mode");
@@ -5791,9 +4943,52 @@ var init_courseDB2 = __esm({
       async updateNavigationStrategy(_id, _data) {
         throw new Error("Cannot update navigation strategies in static mode");
       }
+      /**
+       * Create a ContentNavigator for this course.
+       *
+       * Loads navigation strategy documents from static data and uses PipelineAssembler
+       * to build a Pipeline. Falls back to default pipeline if no strategies found.
+       */
+      async createNavigator(user) {
+        try {
+          const allStrategies = await this.getAllNavigationStrategies();
+          if (allStrategies.length === 0) {
+            logger.debug(
+              "[static/courseDB] No strategy documents found, using default Pipeline(Composite(ELO, SRS), [eloDistanceFilter])"
+            );
+            return createDefaultPipeline(user, this);
+          }
+          const assembler = new PipelineAssembler();
+          const { pipeline, generatorStrategies, filterStrategies, warnings } = await assembler.assemble({
+            strategies: allStrategies,
+            user,
+            course: this
+          });
+          for (const warning of warnings) {
+            logger.warn(`[PipelineAssembler] ${warning}`);
+          }
+          if (!pipeline) {
+            logger.debug("[static/courseDB] Pipeline assembly failed, using default pipeline");
+            return createDefaultPipeline(user, this);
+          }
+          logger.debug(
+            `[static/courseDB] Using assembled pipeline with ${generatorStrategies.length} generator(s) and ${filterStrategies.length} filter(s)`
+          );
+          return pipeline;
+        } catch (e) {
+          logger.error(`[static/courseDB] Error creating navigator: ${e}`);
+          throw e;
+        }
+      }
       // Study Content Source implementation
-      async getPendingReviews() {
-        return [];
+      async getWeightedCards(limit) {
+        try {
+          const navigator = await this.createNavigator(this.userDB);
+          return navigator.getWeightedCards(limit);
+        } catch (e) {
+          logger.error(`[static/courseDB] Error getting weighted cards: ${e}`);
+          throw e;
+        }
       }
       // Attachment helper methods (internal use, not part of interface)
       /**
@@ -6192,108 +5387,71 @@ var init_TagFilteredContentSource = __esm({
         return finalCardIds;
       }
       /**
-       * Gets new cards that match the tag filter and are not already active for the user.
+       * Get cards with suitability scores for presentation.
+       *
+       * Filters cards by tag inclusion/exclusion and assigns score=1.0 to all.
+       * TagFilteredContentSource does not currently support pluggable navigation
+       * strategies - it returns flat-scored candidates.
+       *
+       * @param limit - Maximum number of cards to return
+       * @returns Cards sorted by score descending (all scores = 1.0)
        */
-      async getNewCards(limit) {
+      async getWeightedCards(limit) {
         if (!hasActiveFilter(this.filter)) {
-          logger.warn("[TagFilteredContentSource] getNewCards called with no active filter");
+          logger.warn("[TagFilteredContentSource] getWeightedCards called with no active filter");
           return [];
         }
         const eligibleCardIds = await this.resolveFilteredCardIds();
         const activeCards = await this.user.getActiveCards();
         const activeCardIds = new Set(activeCards.map((c) => c.cardID));
-        const newItems = [];
+        const newCardWeighted = [];
         for (const cardId of eligibleCardIds) {
           if (!activeCardIds.has(cardId)) {
-            newItems.push({
-              courseID: this.courseId,
-              cardID: cardId,
-              contentSourceType: "course",
-              contentSourceID: this.courseId,
-              status: "new"
+            newCardWeighted.push({
+              cardId,
+              courseId: this.courseId,
+              score: 1,
+              provenance: [
+                {
+                  strategy: "tagFilter",
+                  strategyName: "Tag Filter",
+                  strategyId: "TAG_FILTER",
+                  action: "generated",
+                  score: 1,
+                  reason: `Tag-filtered new card (tags: ${this.filter.include.join(", ")})`
+                }
+              ]
             });
           }
-          if (limit !== void 0 && newItems.length >= limit) {
+          if (newCardWeighted.length >= limit) {
             break;
           }
         }
-        logger.info(`[TagFilteredContentSource] Found ${newItems.length} new cards matching filter`);
-        return newItems;
-      }
-      /**
-       * Gets pending reviews, filtered to only include cards that match the tag filter.
-       */
-      async getPendingReviews() {
-        if (!hasActiveFilter(this.filter)) {
-          logger.warn("[TagFilteredContentSource] getPendingReviews called with no active filter");
-          return [];
-        }
-        const eligibleCardIds = await this.resolveFilteredCardIds();
+        logger.info(
+          `[TagFilteredContentSource] Found ${newCardWeighted.length} new cards matching filter`
+        );
         const allReviews = await this.user.getPendingReviews(this.courseId);
-        const filteredReviews = allReviews.filter((review) => {
-          return eligibleCardIds.has(review.cardId);
-        });
+        const filteredReviews = allReviews.filter((review) => eligibleCardIds.has(review.cardId));
         logger.info(
           `[TagFilteredContentSource] Found ${filteredReviews.length} pending reviews matching filter (of ${allReviews.length} total)`
         );
-        return filteredReviews.map((r) => ({
-          ...r,
-          courseID: r.courseId,
-          cardID: r.cardId,
-          contentSourceType: "course",
-          contentSourceID: this.courseId,
+        const reviewWeighted = filteredReviews.map((r) => ({
+          cardId: r.cardId,
+          courseId: r.courseId,
+          score: 1,
           reviewID: r._id,
-          status: "review"
+          provenance: [
+            {
+              strategy: "tagFilter",
+              strategyName: "Tag Filter",
+              strategyId: "TAG_FILTER",
+              action: "generated",
+              score: 1,
+              reason: `Tag-filtered review (tags: ${this.filter.include.join(", ")})`
+            }
+          ]
         }));
-      }
-      /**
-       * Get cards with suitability scores for presentation.
-       *
-       * This implementation wraps the legacy getNewCards/getPendingReviews methods,
-       * assigning score=1.0 to all cards. TagFilteredContentSource does not currently
-       * support pluggable navigation strategies - it returns flat-scored candidates.
-       *
-       * @param limit - Maximum number of cards to return
-       * @returns Cards sorted by score descending (all scores = 1.0)
-       */
-      async getWeightedCards(limit) {
-        const [newCards, reviews] = await Promise.all([
-          this.getNewCards(limit),
-          this.getPendingReviews()
-        ]);
-        const weighted = [
-          ...reviews.map((r) => ({
-            cardId: r.cardID,
-            courseId: r.courseID,
-            score: 1,
-            provenance: [
-              {
-                strategy: "tagFilter",
-                strategyName: "Tag Filter",
-                strategyId: "TAG_FILTER",
-                action: "generated",
-                score: 1,
-                reason: `Tag-filtered review (tags: ${this.filter.include.join(", ")})`
-              }
-            ]
-          })),
-          ...newCards.map((c) => ({
-            cardId: c.cardID,
-            courseId: c.courseID,
-            score: 1,
-            provenance: [
-              {
-                strategy: "tagFilter",
-                strategyName: "Tag Filter",
-                strategyId: "TAG_FILTER",
-                action: "generated",
-                score: 1,
-                reason: `Tag-filtered new card (tags: ${this.filter.include.join(", ")})`
-              }
-            ]
-          }))
-        ];
-        return weighted.slice(0, limit);
+        return [...reviewWeighted, ...newCardWeighted].slice(0, limit);
       }
       /**
        * Clears the cached resolved card IDs.
@@ -6384,6 +5542,16 @@ var init_user = __esm({
   }
 });
 
+// src/core/types/strategyState.ts
+function buildStrategyStateId(courseId, strategyKey) {
+  return `STRATEGY_STATE::${courseId}::${strategyKey}`;
+}
+var init_strategyState = __esm({
+  "src/core/types/strategyState.ts"() {
+    "use strict";
+  }
+});
+
 // src/core/bulkImport/cardProcessor.ts
 import { Status as Status5 } from "@vue-skuilder/common";
 async function importParsedCards(parsedCards, courseDB, config) {
@@ -6505,7 +5673,7 @@ var init_cardProcessor = __esm({
 });
 
 // src/core/bulkImport/types.ts
-var init_types3 = __esm({
+var init_types = __esm({
   "src/core/bulkImport/types.ts"() {
     "use strict";
   }
@@ -6516,7 +5684,7 @@ var init_bulkImport = __esm({
   "src/core/bulkImport/index.ts"() {
     "use strict";
     init_cardProcessor();
-    init_types3();
+    init_types();
   }
 });
 
@@ -6527,6 +5695,7 @@ var init_core = __esm({
     init_interfaces();
     init_types_legacy();
     init_user();
+    init_strategyState();
     init_Loggable();
     init_util();
     init_navigators();
@@ -6649,7 +5818,7 @@ var SrsService = class {
 
 // src/study/services/EloService.ts
 init_logger();
-import { adjustCourseScores, toCourseElo as toCourseElo7 } from "@vue-skuilder/common";
+import { adjustCourseScores, toCourseElo as toCourseElo5 } from "@vue-skuilder/common";
 var EloService = class {
   dataLayer;
   user;
@@ -6671,7 +5840,7 @@ var EloService = class {
       logger.warn(`k value interpretation not currently implemented`);
     }
     const courseDB = this.dataLayer.getCourseDB(currentCard.card.course_id);
-    const userElo = toCourseElo7(userCourseRegDoc.courses.find((c) => c.courseID === course_id).elo);
+    const userElo = toCourseElo5(userCourseRegDoc.courses.find((c) => c.courseID === course_id).elo);
     const cardElo = (await courseDB.getCardEloData([currentCard.card.card_id]))[0];
     if (cardElo && userElo) {
       const eloUpdate = adjustCourseScores(userElo, cardElo, userScore);
@@ -6880,156 +6049,124 @@ init_logger();
 import {
   displayableDataToViewData,
   isCourseElo,
-  toCourseElo as toCourseElo8
+  toCourseElo as toCourseElo6
 } from "@vue-skuilder/common";
-
-// src/study/ItemQueue.ts
-var ItemQueue = class {
-  q = [];
-  seenCardIds = [];
-  _dequeueCount = 0;
-  get dequeueCount() {
-    return this._dequeueCount;
-  }
-  add(item, cardId) {
-    if (this.seenCardIds.find((d) => d === cardId)) {
-      return;
-    }
-    this.seenCardIds.push(cardId);
-    this.q.push(item);
-  }
-  addAll(items, cardIdExtractor) {
-    items.forEach((i) => this.add(i, cardIdExtractor(i)));
-  }
-  get length() {
-    return this.q.length;
-  }
-  peek(index) {
-    return this.q[index];
-  }
-  dequeue(cardIdExtractor) {
-    if (this.q.length !== 0) {
-      this._dequeueCount++;
-      const item = this.q.splice(0, 1)[0];
-      if (cardIdExtractor) {
-        const cardId = cardIdExtractor(item);
-        const index = this.seenCardIds.indexOf(cardId);
-        if (index > -1) {
-          this.seenCardIds.splice(index, 1);
-        }
-      }
-      return item;
-    } else {
-      return null;
-    }
-  }
-  get toString() {
-    return `${typeof this.q[0]}:
-` + this.q.map((i) => `	${i.courseID}+${i.cardID}: ${i.status}`).join("\n");
-  }
-};
-
-// src/study/services/CardHydrationService.ts
+function parseAudioURIs(data) {
+  if (typeof data !== "string") return [];
+  const audioPattern = /https?:\/\/[^\s"'<>]+\.(wav|mp3|ogg|m4a|aac|webm)/gi;
+  return data.match(audioPattern) ?? [];
+}
+function prefetchAudio(url) {
+  return new Promise((resolve) => {
+    const audio = new Audio();
+    audio.preload = "auto";
+    const cleanup = () => {
+      audio.oncanplaythrough = null;
+      audio.onerror = null;
+    };
+    audio.oncanplaythrough = () => {
+      cleanup();
+      resolve();
+    };
+    audio.onerror = () => {
+      cleanup();
+      logger.warn(`[CardHydrationService] Failed to prefetch audio: ${url}`);
+      resolve();
+    };
+    audio.src = url;
+  });
+}
 var CardHydrationService = class {
-  constructor(getViewComponent, getCourseDB3, selectNextItemToHydrate, removeItemFromQueue, hasAvailableCards) {
+  constructor(getViewComponent, getCourseDB3, getItemsToHydrate) {
     this.getViewComponent = getViewComponent;
     this.getCourseDB = getCourseDB3;
-    this.selectNextItemToHydrate = selectNextItemToHydrate;
-    this.removeItemFromQueue = removeItemFromQueue;
-    this.hasAvailableCards = hasAvailableCards;
+    this.getItemsToHydrate = getItemsToHydrate;
   }
-  hydratedQ = new ItemQueue();
-  failedCardCache = /* @__PURE__ */ new Map();
+  hydratedCards = /* @__PURE__ */ new Map();
+  hydrationInFlight = /* @__PURE__ */ new Set();
   hydrationInProgress = false;
-  BUFFER_SIZE = 5;
   /**
-   * Get the next hydrated card from the queue.
-   * @returns Hydrated card or null if none available
+   * Get a hydrated card by ID.
+   * @returns Hydrated card or null if not in cache
+   */
+  getHydratedCard(cardId) {
+    return this.hydratedCards.get(cardId) ?? null;
+  }
+  /**
+   * Check if a card is hydrated.
    */
-  dequeueHydratedCard() {
-    return this.hydratedQ.dequeue((item) => item.item.cardID);
+  hasHydratedCard(cardId) {
+    return this.hydratedCards.has(cardId);
+  }
+  /**
+   * Remove a card from the cache (call on successful dismiss to free memory).
+   */
+  removeCard(cardId) {
+    this.hydratedCards.delete(cardId);
   }
   /**
    * Check if hydration should be triggered and start background hydration if needed.
    */
   async ensureHydratedCards() {
-    if (this.hydratedQ.length < 3) {
-      void this.fillHydratedQueue();
-    }
+    void this.fillHydratedCards();
   }
   /**
-   * Wait for a hydrated card to become available.
+   * Wait for a specific card to become hydrated.
    * @returns Promise that resolves to a hydrated card or null
    */
-  async waitForHydratedCard() {
-    if (this.hydratedQ.length === 0 && this.hasAvailableCards()) {
-      void this.fillHydratedQueue();
+  async waitForCard(cardId) {
+    if (this.hydratedCards.has(cardId)) {
+      return this.hydratedCards.get(cardId);
     }
-    while (this.hydratedQ.length === 0 && this.hasAvailableCards()) {
-      await new Promise((resolve) => setTimeout(resolve, 25));
+    if (!this.hydrationInProgress) {
+      void this.fillHydratedCards();
     }
-    return this.dequeueHydratedCard();
+    const maxWaitMs = 1e4;
+    const pollIntervalMs = 25;
+    let elapsed = 0;
+    while (elapsed < maxWaitMs) {
+      if (this.hydratedCards.has(cardId)) {
+        return this.hydratedCards.get(cardId);
+      }
+      if (!this.hydrationInFlight.has(cardId) && !this.hydrationInProgress) {
+        break;
+      }
+      await new Promise((resolve) => setTimeout(resolve, pollIntervalMs));
+      elapsed += pollIntervalMs;
+    }
+    return this.hydratedCards.get(cardId) ?? null;
   }
   /**
-   * Get current hydrated queue length.
+   * Get current hydrated cache size.
    */
   get hydratedCount() {
-    return this.hydratedQ.length;
+    return this.hydratedCards.size;
   }
   /**
-   * Get current failed card cache size.
+   * Get list of currently hydrated card IDs (for debugging).
    */
-  get failedCacheSize() {
-    return this.failedCardCache.size;
+  getHydratedCardIds() {
+    return Array.from(this.hydratedCards.keys());
   }
   /**
-   * Fill the hydrated queue up to BUFFER_SIZE with pre-fetched cards.
+   * Fill the hydrated cache by hydrating items from getItemsToHydrate().
+   * This is a pure cache-warming operation - no queue mutation.
    */
-  async fillHydratedQueue() {
+  async fillHydratedCards() {
     if (this.hydrationInProgress) {
       return;
     }
     this.hydrationInProgress = true;
     try {
-      while (this.hydratedQ.length < this.BUFFER_SIZE) {
-        const nextItem = this.selectNextItemToHydrate();
-        if (!nextItem) {
-          return;
+      const itemsToHydrate = this.getItemsToHydrate();
+      for (const item of itemsToHydrate) {
+        if (this.hydratedCards.has(item.cardID) || this.hydrationInFlight.has(item.cardID)) {
+          continue;
         }
         try {
-          if (this.failedCardCache.has(nextItem.cardID)) {
-            const cachedCard = this.failedCardCache.get(nextItem.cardID);
-            this.hydratedQ.add(cachedCard, cachedCard.item.cardID);
-            this.failedCardCache.delete(nextItem.cardID);
-          } else {
-            const courseDB = this.getCourseDB(nextItem.courseID);
-            const cardData = await courseDB.getCourseDoc(nextItem.cardID);
-            if (!isCourseElo(cardData.elo)) {
-              cardData.elo = toCourseElo8(cardData.elo);
-            }
-            const view = this.getViewComponent(cardData.id_view);
-            const dataDocs = await Promise.all(
-              cardData.id_displayable_data.map(
-                (id) => courseDB.getCourseDoc(id, {
-                  attachments: true,
-                  binary: true
-                })
-              )
-            );
-            const data = dataDocs.map(displayableDataToViewData).reverse();
-            this.hydratedQ.add(
-              {
-                item: nextItem,
-                view,
-                data
-              },
-              nextItem.cardID
-            );
-          }
+          await this.hydrateCard(item);
         } catch (e) {
-          logger.error(`Error hydrating card ${nextItem.cardID}:`, e);
-        } finally {
-          this.removeItemFromQueue(nextItem);
+          logger.error(`[CardHydrationService] Error hydrating card ${item.cardID}:`, e);
         }
       }
     } finally {
@@ -7037,10 +6174,97 @@ var CardHydrationService = class {
     }
   }
   /**
-   * Cache a failed card for quick re-access.
+   * Hydrate a single card and add to cache.
    */
-  cacheFailedCard(card) {
-    this.failedCardCache.set(card.item.cardID, card);
+  async hydrateCard(item) {
+    if (this.hydratedCards.has(item.cardID) || this.hydrationInFlight.has(item.cardID)) {
+      return;
+    }
+    this.hydrationInFlight.add(item.cardID);
+    try {
+      const courseDB = this.getCourseDB(item.courseID);
+      const cardData = await courseDB.getCourseDoc(item.cardID);
+      if (!isCourseElo(cardData.elo)) {
+        cardData.elo = toCourseElo6(cardData.elo);
+      }
+      const view = this.getViewComponent(cardData.id_view);
+      const dataDocs = await Promise.all(
+        cardData.id_displayable_data.map(
+          (id) => courseDB.getCourseDoc(id, {
+            attachments: true,
+            binary: true
+          })
+        )
+      );
+      const audioToPrefetch = [];
+      dataDocs.forEach((dd) => {
+        dd.data.forEach((f) => {
+          audioToPrefetch.push(...parseAudioURIs(f.data));
+        });
+      });
+      const uniqueAudioUrls = [...new Set(audioToPrefetch)];
+      if (uniqueAudioUrls.length > 0) {
+        logger.debug(
+          `[CardHydrationService] Prefetching ${uniqueAudioUrls.length} audio files for card ${item.cardID}`
+        );
+        await Promise.allSettled(uniqueAudioUrls.map(prefetchAudio));
+      }
+      const data = dataDocs.map(displayableDataToViewData).reverse();
+      this.hydratedCards.set(item.cardID, {
+        item,
+        view,
+        data
+      });
+      logger.debug(`[CardHydrationService] Hydrated card ${item.cardID}`);
+    } finally {
+      this.hydrationInFlight.delete(item.cardID);
+    }
+  }
+};
+
+// src/study/ItemQueue.ts
+var ItemQueue = class {
+  q = [];
+  seenCardIds = [];
+  _dequeueCount = 0;
+  get dequeueCount() {
+    return this._dequeueCount;
+  }
+  add(item, cardId) {
+    if (this.seenCardIds.find((d) => d === cardId)) {
+      return;
+    }
+    this.seenCardIds.push(cardId);
+    this.q.push(item);
+  }
+  addAll(items, cardIdExtractor) {
+    items.forEach((i) => this.add(i, cardIdExtractor(i)));
+  }
+  get length() {
+    return this.q.length;
+  }
+  peek(index) {
+    return this.q[index];
+  }
+  dequeue(cardIdExtractor) {
+    if (this.q.length !== 0) {
+      this._dequeueCount++;
+      const item = this.q.splice(0, 1)[0];
+      if (cardIdExtractor) {
+        const cardId = cardIdExtractor(item);
+        const index = this.seenCardIds.indexOf(cardId);
+        if (index > -1) {
+          this.seenCardIds.splice(index, 1);
+        }
+      }
+      return item;
+    } else {
+      return null;
+    }
+  }
+  get toString() {
+    return `${typeof this.q[0]}:
+` + this.q.map((i) => `	${i.courseID}+${i.cardID}: ${i.status}`).join("\n");
   }
 };
 
@@ -7582,7 +6806,7 @@ try {
   }
 } catch {
 }
-async function validateStaticCourse(staticPath, fs3) {
+async function validateStaticCourse(staticPath, fs2) {
   const validation = {
     valid: true,
     manifestExists: false,
@@ -7592,8 +6816,8 @@ async function validateStaticCourse(staticPath, fs3) {
     warnings: []
   };
   try {
-    if (fs3) {
-      const stats = await fs3.stat(staticPath);
+    if (fs2) {
+      const stats = await fs2.stat(staticPath);
       if (!stats.isDirectory()) {
         validation.errors.push(`Path is not a directory: ${staticPath}`);
         validation.valid = false;
@@ -7613,11 +6837,11 @@ async function validateStaticCourse(staticPath, fs3) {
     }
     let manifestPath = `${staticPath}/manifest.json`;
     try {
-      if (fs3) {
-        manifestPath = fs3.joinPath(staticPath, "manifest.json");
-        if (await fs3.exists(manifestPath)) {
+      if (fs2) {
+        manifestPath = fs2.joinPath(staticPath, "manifest.json");
+        if (await fs2.exists(manifestPath)) {
           validation.manifestExists = true;
-          const manifestContent = await fs3.readFile(manifestPath);
+          const manifestContent = await fs2.readFile(manifestPath);
           const manifest = JSON.parse(manifestContent);
           validation.courseId = manifest.courseId;
           validation.courseName = manifest.courseName;
@@ -7649,10 +6873,10 @@ async function validateStaticCourse(staticPath, fs3) {
     }
     let chunksPath = `${staticPath}/chunks`;
     try {
-      if (fs3) {
-        chunksPath = fs3.joinPath(staticPath, "chunks");
-        if (await fs3.exists(chunksPath)) {
-          const chunksStats = await fs3.stat(chunksPath);
+      if (fs2) {
+        chunksPath = fs2.joinPath(staticPath, "chunks");
+        if (await fs2.exists(chunksPath)) {
+          const chunksStats = await fs2.stat(chunksPath);
           if (chunksStats.isDirectory()) {
             validation.chunksExist = true;
           } else {
@@ -7680,10 +6904,10 @@ async function validateStaticCourse(staticPath, fs3) {
     }
     let attachmentsPath;
     try {
-      if (fs3) {
-        attachmentsPath = fs3.joinPath(staticPath, "attachments");
-        if (await fs3.exists(attachmentsPath)) {
-          const attachmentsStats = await fs3.stat(attachmentsPath);
+      if (fs2) {
+        attachmentsPath = fs2.joinPath(staticPath, "attachments");
+        if (await fs2.exists(attachmentsPath)) {
+          const attachmentsStats = await fs2.stat(attachmentsPath);
           if (attachmentsStats.isDirectory()) {
             validation.attachmentsExist = true;
           }
@@ -8461,26 +7685,43 @@ var StaticToCouchDBMigrator = class {
   /**
    * Check if a path is a local file path (vs URL)
    */
-  isLocalPath(path3) {
-    return !path3.startsWith("http://") && !path3.startsWith("https://");
+  isLocalPath(path2) {
+    return !path2.startsWith("http://") && !path2.startsWith("https://");
   }
 };
 
 // src/util/index.ts
 init_dataDirectory();
-init_tuiLogger();
 
 // src/study/SessionController.ts
 init_navigators();
-function randomInt(min, max) {
-  return Math.floor(Math.random() * (max - min + 1)) + min;
-}
+
+// src/study/SourceMixer.ts
+var QuotaRoundRobinMixer = class {
+  mix(batches, limit) {
+    if (batches.length === 0) {
+      return [];
+    }
+    const quotaPerSource = Math.ceil(limit / batches.length);
+    const mixed = [];
+    for (const batch of batches) {
+      const sortedBatch = [...batch.weighted].sort((a, b) => b.score - a.score);
+      const topFromSource = sortedBatch.slice(0, quotaPerSource);
+      mixed.push(...topFromSource);
+    }
+    return mixed.sort((a, b) => b.score - a.score).slice(0, limit);
+  }
+};
+
+// src/study/SessionController.ts
+init_logger();
 var SessionController = class extends Loggable {
   _className = "SessionController";
   services;
   srsService;
   eloService;
   hydrationService;
+  mixer;
   sources;
   // dataLayer and getViewComponent now injected into CardHydrationService
   _sessionRecord = [];
@@ -8508,18 +7749,21 @@ var SessionController = class extends Loggable {
   // @ts-expect-error NodeJS.Timeout type not available in browser context
   _intervalHandle;
   /**
-   *
+   * @param sources - Array of content sources to mix for the session
+   * @param time - Session duration in seconds
+   * @param dataLayer - Data layer provider
+   * @param getViewComponent - Function to resolve view components
+   * @param mixer - Optional source mixer strategy (defaults to QuotaRoundRobinMixer)
    */
-  constructor(sources, time, dataLayer, getViewComponent) {
+  constructor(sources, time, dataLayer, getViewComponent, mixer) {
     super();
+    this.mixer = mixer || new QuotaRoundRobinMixer();
     this.srsService = new SrsService(dataLayer.getUserDB());
     this.eloService = new EloService(dataLayer, dataLayer.getUserDB());
     this.hydrationService = new CardHydrationService(
       getViewComponent,
       (courseId) => dataLayer.getCourseDB(courseId),
-      () => this._selectNextItemToHydrate(),
-      (item) => this.removeItemFromQueue(item),
-      () => this.hasAvailableCards()
+      () => this._getItemsToHydrate()
     );
     this.services = {
       response: new ResponseProcessor(this.srsService, this.eloService)
@@ -8573,16 +7817,12 @@ var SessionController = class extends Loggable {
     return ret;
   }
   async prepareSession() {
-    try {
-      const hasWeightedCards = this.sources.some((s) => typeof s.getWeightedCards === "function");
-      if (hasWeightedCards) {
-        await this.getWeightedContent();
-      } else {
-        await Promise.all([this.getScheduledReviews(), this.getNewCards()]);
-      }
-    } catch (e) {
-      this.error("Error preparing study session:", e);
+    if (this.sources.some((s) => typeof s.getWeightedCards !== "function")) {
+      throw new Error(
+        "[SessionController] All content sources must implement getWeightedCards()."
+      );
     }
+    await this.getWeightedContent();
     await this.hydrationService.ensureHydratedCards();
     this._intervalHandle = setInterval(() => {
       this.tick();
@@ -8620,14 +7860,10 @@ var SessionController = class extends Loggable {
       }
       return items;
     };
-    const extractHydratedItems = () => {
-      const items = [];
-      return items;
-    };
     return {
       api: {
         mode: supportsWeightedCards ? "weighted" : "legacy",
-        description: supportsWeightedCards ? "Using getWeightedCards() API with scored candidates" : "Using legacy getNewCards()/getPendingReviews() API"
+        description: supportsWeightedCards ? "Using getWeightedCards() API with scored candidates" : "ERROR: getWeightedCards() not a function."
       },
       reviewQueue: {
         length: this.reviewQ.length,
@@ -8646,162 +7882,97 @@ var SessionController = class extends Loggable {
       },
       hydratedCache: {
         count: this.hydrationService.hydratedCount,
-        failedCacheSize: this.hydrationService.failedCacheSize,
-        items: extractHydratedItems()
+        cardIds: this.hydrationService.getHydratedCardIds()
       }
     };
   }
   /**
-   * Fetch content using the new getWeightedCards API.
+   * Fetch content using the getWeightedCards API and mix across sources.
    *
-   * This method uses getWeightedCards() to get scored candidates, then uses the
-   * scores to determine ordering. For reviews, we still need the full ScheduledCard
-   * data from getPendingReviews(), so we fetch both and use scores for ordering.
-   *
-   * The hybrid approach:
-   * 1. Fetch weighted cards to get scoring/ordering information
-   * 2. Fetch full review data via legacy getPendingReviews()
-   * 3. Order reviews by their weighted scores
-   * 4. Add new cards ordered by their weighted scores
+   * This method:
+   * 1. Fetches weighted cards from each source
+   * 2. Fetches full review data (we need ScheduledCard fields for queue)
+   * 3. Uses SourceMixer to balance content across sources
+   * 4. Populates review and new card queues with mixed results
    */
   async getWeightedContent() {
     const limit = 20;
-    const allWeighted = [];
-    const allReviews = [];
-    const allNewCards = [];
-    for (const source of this.sources) {
+    const batches = [];
+    for (let i = 0; i < this.sources.length; i++) {
+      const source = this.sources[i];
       try {
-        const reviews = await source.getPendingReviews().catch((error) => {
-          this.error(`Failed to get reviews for source:`, error);
-          return [];
+        const weighted = await source.getWeightedCards(limit);
+        batches.push({
+          sourceIndex: i,
+          weighted
         });
-        allReviews.push(...reviews);
-        if (typeof source.getWeightedCards === "function") {
-          const weighted = await source.getWeightedCards(limit);
-          allWeighted.push(...weighted);
-        } else {
-          const newCards = await source.getNewCards(limit);
-          allNewCards.push(...newCards);
-          allWeighted.push(
-            ...newCards.map((c) => ({
-              cardId: c.cardID,
-              courseId: c.courseID,
-              score: 1,
-              provenance: [
-                {
-                  strategy: "legacy",
-                  strategyName: "Legacy Fallback",
-                  strategyId: "legacy-fallback",
-                  action: "generated",
-                  score: 1,
-                  reason: "Fallback to legacy getNewCards(), new card"
-                }
-              ]
-            })),
-            ...reviews.map((r) => ({
-              cardId: r.cardID,
-              courseId: r.courseID,
-              score: 1,
-              provenance: [
-                {
-                  strategy: "legacy",
-                  strategyName: "Legacy Fallback",
-                  strategyId: "legacy-fallback",
-                  action: "generated",
-                  score: 1,
-                  reason: "Fallback to legacy getPendingReviews(), review"
-                }
-              ]
-            }))
-          );
-        }
       } catch (error) {
-        this.error(`Failed to get content from source:`, error);
+        this.error(`Failed to get content from source ${i}:`, error);
+        if (this.sources.length === 1) {
+          throw new Error(`Cannot start session: failed to load content from source ${i}`);
+        }
       }
     }
-    const scoreMap = /* @__PURE__ */ new Map();
-    for (const w of allWeighted) {
-      const key = `${w.courseId}::${w.cardId}`;
-      scoreMap.set(key, w.score);
+    if (batches.length === 0) {
+      throw new Error(
+        `Cannot start session: failed to load content from all ${this.sources.length} source(s). Check logs for details.`
+      );
     }
-    const scoredReviews = allReviews.map((r) => ({
-      review: r,
-      score: scoreMap.get(`${r.courseID}::${r.cardID}`) ?? 1
-    }));
-    scoredReviews.sort((a, b) => b.score - a.score);
-    let report = "Weighted content session created with:\n";
-    for (const { review, score } of scoredReviews) {
-      this.reviewQ.add(review, review.cardID);
-      report += `Review: ${review.courseID}::${review.cardID} (score: ${score.toFixed(2)})
+    const mixedWeighted = this.mixer.mix(batches, limit * this.sources.length);
+    const reviewWeighted = mixedWeighted.filter((w) => getCardOrigin(w) === "review");
+    const newWeighted = mixedWeighted.filter((w) => getCardOrigin(w) === "new");
+    logger.debug(`[reviews] got ${reviewWeighted.length} reviews from mixer`);
+    let report = "Mixed content session created with:\n";
+    for (const w of reviewWeighted) {
+      const reviewItem = {
+        cardID: w.cardId,
+        courseID: w.courseId,
+        contentSourceType: "course",
+        contentSourceID: w.courseId,
+        reviewID: w.reviewID,
+        status: "review"
+      };
+      this.reviewQ.add(reviewItem, reviewItem.cardID);
+      report += `Review: ${w.courseId}::${w.cardId} (score: ${w.score.toFixed(2)})
 `;
     }
-    const newCardWeighted = allWeighted.filter((w) => getCardOrigin(w) === "new").sort((a, b) => b.score - a.score);
-    for (const card of newCardWeighted) {
+    for (const w of newWeighted) {
       const newItem = {
-        cardID: card.cardId,
-        courseID: card.courseId,
+        cardID: w.cardId,
+        courseID: w.courseId,
         contentSourceType: "course",
-        contentSourceID: card.courseId,
+        contentSourceID: w.courseId,
         status: "new"
       };
-      this.newQ.add(newItem, card.cardId);
-      report += `New: ${card.courseId}::${card.cardId} (score: ${card.score.toFixed(2)})
+      this.newQ.add(newItem, newItem.cardID);
+      report += `New: ${w.courseId}::${w.cardId} (score: ${w.score.toFixed(2)})
 `;
     }
     this.log(report);
   }
   /**
-   * @deprecated Use getWeightedContent() instead. This method is kept for backward
-   * compatibility with sources that don't support getWeightedCards().
+   * Returns items that should be pre-hydrated.
+   * Deterministic: top N items from each queue to ensure coverage.
+   * Failed queue items will typically already be hydrated (from initial render).
    */
-  async getScheduledReviews() {
-    const reviews = await Promise.all(
-      this.sources.map(
-        (c) => c.getPendingReviews().catch((error) => {
-          this.error(`Failed to get reviews for source ${c}:`, error);
-          return [];
-        })
-      )
-    );
-    const dueCards = [];
-    while (reviews.length != 0 && reviews.some((r) => r.length > 0)) {
-      const index = randomInt(0, reviews.length - 1);
-      const source = reviews[index];
-      if (source.length === 0) {
-        reviews.splice(index, 1);
-        continue;
-      } else {
-        dueCards.push(source.shift());
-      }
+  _getItemsToHydrate() {
+    const items = [];
+    const ITEMS_PER_QUEUE = 2;
+    for (let i = 0; i < Math.min(ITEMS_PER_QUEUE, this.reviewQ.length); i++) {
+      items.push(this.reviewQ.peek(i));
     }
-    let report = "Review session created with:\n";
-    this.reviewQ.addAll(dueCards, (c) => c.cardID);
-    report += dueCards.map((card) => `Card ${card.courseID}::${card.cardID} `).join("\n");
-    this.log(report);
+    for (let i = 0; i < Math.min(ITEMS_PER_QUEUE, this.newQ.length); i++) {
+      items.push(this.newQ.peek(i));
+    }
+    for (let i = 0; i < Math.min(ITEMS_PER_QUEUE, this.failedQ.length); i++) {
+      items.push(this.failedQ.peek(i));
+    }
+    return items;
   }
   /**
-   * @deprecated Use getWeightedContent() instead. This method is kept for backward
-   * compatibility with sources that don't support getWeightedCards().
+   * Selects the next item to present to the user.
+   * Nondeterministic: uses probability to balance between queues based on session state.
    */
-  async getNewCards(n = 10) {
-    const perCourse = Math.ceil(n / this.sources.length);
-    const newContent = await Promise.all(this.sources.map((c) => c.getNewCards(perCourse)));
-    newContent.forEach((newContentFromSource) => {
-      newContentFromSource.filter((c) => {
-        return this._sessionRecord.find((record) => record.card.card_id === c.cardID) === void 0;
-      });
-    });
-    while (n > 0 && newContent.some((nc) => nc.length > 0)) {
-      for (let i = 0; i < newContent.length; i++) {
-        if (newContent[i].length > 0) {
-          const item = newContent[i].splice(0, 1)[0];
-          this.log(`Adding new card: ${item.courseID}::${item.cardID}`);
-          this.newQ.add(item, item.cardID);
-          n--;
-        }
-      }
-    }
-  }
   _selectNextItemToHydrate() {
     const choice = Math.random();
     let newBound = 0.1;
@@ -8858,16 +8029,18 @@ var SessionController = class extends Loggable {
       this._currentCard = null;
       return null;
     }
-    let card = this.hydrationService.dequeueHydratedCard();
-    if (!card && this.hasAvailableCards()) {
-      card = await this.hydrationService.waitForHydratedCard();
-    }
-    await this.hydrationService.ensureHydratedCards();
-    if (card) {
-      this._currentCard = card;
-    } else {
+    const nextItem = this._selectNextItemToHydrate();
+    if (!nextItem) {
       this._currentCard = null;
+      return null;
     }
+    let card = this.hydrationService.getHydratedCard(nextItem.cardID);
+    if (!card) {
+      card = await this.hydrationService.waitForCard(nextItem.cardID);
+    }
+    this.removeItemFromQueue(nextItem);
+    await this.hydrationService.ensureHydratedCards();
+    this._currentCard = card;
     return card;
   }
   /**
@@ -8903,8 +8076,8 @@ var SessionController = class extends Loggable {
   dismissCurrentCard(action = "dismiss-success") {
     if (this._currentCard) {
       if (action === "dismiss-success") {
+        this.hydrationService.removeCard(this._currentCard.item.cardID);
       } else if (action === "marked-failed") {
-        this.hydrationService.cacheFailedCard(this._currentCard);
         let failedItem;
         if (isReview(this._currentCard.item)) {
           failedItem = {
@@ -8926,22 +8099,21 @@ var SessionController = class extends Loggable {
         }
         this.failedQ.add(failedItem, failedItem.cardID);
       } else if (action === "dismiss-error") {
+        this.hydrationService.removeCard(this._currentCard.item.cardID);
       } else if (action === "dismiss-failed") {
+        this.hydrationService.removeCard(this._currentCard.item.cardID);
       }
     }
   }
-  hasAvailableCards() {
-    return this.reviewQ.length > 0 || this.newQ.length > 0 || this.failedQ.length > 0;
-  }
   /**
-   * Helper method for CardHydrationService to remove items from appropriate queue.
+   * Remove an item from its source queue after consumption by nextCard().
    */
   removeItemFromQueue(item) {
-    if (this.reviewQ.peek(0) === item) {
+    if (this.reviewQ.peek(0)?.cardID === item.cardID) {
       this.reviewQ.dequeue((queueItem) => queueItem.cardID);
-    } else if (this.newQ.peek(0) === item) {
+    } else if (this.newQ.peek(0)?.cardID === item.cardID) {
       this.newQ.dequeue((queueItem) => queueItem.cardID);
-    } else {
+    } else if (this.failedQ.peek(0)?.cardID === item.cardID) {
       this.failedQ.dequeue((queueItem) => queueItem.cardID);
     }
   }
@@ -8966,11 +8138,13 @@ export {
   NavigatorRole,
   NavigatorRoles,
   Navigators,
+  QuotaRoundRobinMixer,
   SessionController,
   StaticToCouchDBMigrator,
   TagFilteredContentSource,
   _resetDataLayer,
   areQuestionRecords,
+  buildStrategyStateId,
   docIsDeleted,
   ensureAppDataDirectory,
   getAppDataDirectory,
@@ -8978,22 +8152,17 @@ export {
   getCardOrigin,
   getDataLayer,
   getDbPath,
-  getLogFilePath,
   getStudySource,
   importParsedCards,
   initializeDataDirectory,
   initializeDataLayer,
-  initializeTuiLogging,
   isFilter,
   isGenerator,
   isQuestionRecord,
   isReview,
   log,
-  logger2 as logger,
   newInterval,
   parseCardHistoryID,
-  showUserError,
-  showUserMessage,
   validateMigration,
   validateProcessorConfig,
   validateStaticCourse