@vue-skuilder/db 0.1.31-b → 0.1.31

package/package.json

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

package/src/core/interfaces/contentSource.ts

@@ -79,6 +79,12 @@ export interface StudyContentSource {
    * Used for recording learning outcomes.
    */
   getOrchestrationContext?(): Promise<OrchestrationContext>;
+
+  /**
+   * Set ephemeral hints for the next pipeline run.
+   * No-op for sources that don't support hints.
+   */
+  setEphemeralHints?(hints: Record<string, unknown>): void;
 }
 // #endregion docs_StudyContentSource
 

package/src/core/interfaces/courseDB.ts

@@ -100,6 +100,12 @@ export interface CourseDBInterface extends NavigationStrategyManager, StudyConte
    */
   getAppliedTagsBatch(cardIds: string[]): Promise<Map<string, string[]>>;
 
+  /**
+   * Get all card IDs in the course.
+   * Used by diagnostics to scan the full card space.
+   */
+  getAllCardIds(): Promise<string[]>;
+
   /**
    * Add a tag to a card
    */

package/src/core/interfaces/dataLayerProvider.ts

@@ -56,4 +56,24 @@ export interface DataLayerProvider {
    * Check if this data layer is read-only
    */
   isReadOnly(): boolean;
+
+  /**
+   * Trigger local replication of a course database.
+   *
+   * When a course opts in via `CourseConfig.localSync.enabled`, this method
+   * replicates the remote course DB to a local PouchDB instance. Subsequent
+   * `getCourseDB()` calls for that course will return a CourseDB that reads
+   * from the local replica (fast, no network) and writes to the remote
+   * (ELO updates, admin ops).
+   *
+   * Safe to call multiple times — concurrent calls coalesce. Returns when
+   * sync is complete (or immediately if already synced / disabled).
+   *
+   * Implementations that don't support local sync may no-op.
+   *
+   * @param courseId - The course to sync locally
+   * @param forceEnabled - Skip CourseConfig check and sync regardless.
+   *   Use when the caller already knows local sync is desired.
+   */
+  ensureCourseSynced?(courseId: string, forceEnabled?: boolean): Promise<void>;
 }

package/src/core/navigators/Pipeline.ts

@@ -7,7 +7,60 @@ import type { CardFilter, FilterContext } from './filters/types';
 import type { CardGenerator, GeneratorContext } from './generators/types';
 import { logger } from '../../util/logger';
 import { createOrchestrationContext, OrchestrationContext } from '../orchestration';
-import { captureRun, buildRunReport, type GeneratorSummary, type FilterImpact } from './PipelineDebugger';
+import { captureRun, buildRunReport, registerPipelineForDebug, type GeneratorSummary, type FilterImpact } from './PipelineDebugger';
+
+// ============================================================================
+// REPLAN HINTS
+// ============================================================================
+//
+// Ephemeral, one-shot scoring hints passed at replan time.
+// Applied after the filter chain, consumed after one pipeline run.
+//
+// Tag patterns support glob-style matching:
+//   'gpc:exercise:t-T'   — exact match
+//   'gpc:intro:*'        — all intro tags
+//   'gpc:exercise:t-*'   — all t-variant exercises
+//
+
+/**
+ * Ephemeral pipeline hints for a single run.
+ * All fields are optional. Tag/card patterns support `*` wildcards.
+ */
+export interface ReplanHints {
+  /** Multiply scores for cards matching these tag patterns. */
+  boostTags?: Record<string, number>;
+  /** Multiply scores for these specific card IDs (glob patterns). */
+  boostCards?: Record<string, number>;
+  /** Cards matching these tag patterns MUST appear in results. */
+  requireTags?: string[];
+  /** These specific card IDs MUST appear in results. */
+  requireCards?: string[];
+  /** Remove cards matching these tag patterns from results. */
+  excludeTags?: string[];
+  /** Remove these specific card IDs from results. */
+  excludeCards?: string[];
+}
+
+/**
+ * Convert a glob pattern (with `*` wildcards) to a RegExp.
+ * Only `*` is supported as a wildcard (matches any characters).
+ */
+function globToRegex(pattern: string): RegExp {
+  const escaped = pattern.replace(/[.+?^${}()|[\]\\]/g, '\\$&');
+  const withWildcards = escaped.replace(/\*/g, '.*');
+  return new RegExp(`^${withWildcards}$`);
+}
+
+/** Test whether a string matches a glob pattern. */
+function globMatch(value: string, pattern: string): boolean {
+  if (!pattern.includes('*')) return value === pattern;
+  return globToRegex(pattern).test(value);
+}
+
+/** Test whether any of a card's tags match a glob pattern. */
+function cardMatchesTagPattern(card: WeightedCard, pattern: string): boolean {
+  return (card.tags ?? []).some((tag) => globMatch(tag, pattern));
+}
 
 // ============================================================================
 // PIPELINE LOGGING HELPERS
@@ -79,6 +132,32 @@ function logExecutionSummary(
   );
 }
 
+/**
+ * Log all result cards with score, cardId, and key provenance.
+ * Toggle: set VERBOSE_RESULTS = true to enable.
+ */
+const VERBOSE_RESULTS = true;
+
+function logResultCards(cards: WeightedCard[]): void {
+  if (!VERBOSE_RESULTS || cards.length === 0) return;
+
+  logger.info(`[Pipeline] Results (${cards.length} cards):`);
+  for (let i = 0; i < cards.length; i++) {
+    const c = cards[i];
+    const tags = c.tags?.slice(0, 3).join(', ') || '';
+    const filters = c.provenance
+      .filter((p) => p.strategy === 'hierarchyDefinition' || p.strategy === 'priorityDefinition' || p.strategy === 'interferenceFilter' || p.strategy === 'letterGating' || p.strategy === 'ephemeralHint')
+      .map((p) => {
+        const arrow = p.action === 'boosted' ? '↑' : p.action === 'penalized' ? '↓' : '=';
+        return `${p.strategyName}${arrow}${p.score.toFixed(2)}`;
+      })
+      .join(' | ');
+    logger.info(
+      `[Pipeline]   ${String(i + 1).padStart(2)}. ${c.score.toFixed(4)}  ${c.cardId}  [${tags}]${filters ? `  {${filters}}` : ''}`
+    );
+  }
+}
+
 /**
  * Log provenance trails for cards.
  * Shows the complete scoring history for each card through the pipeline.
@@ -145,6 +224,30 @@ export class Pipeline extends ContentNavigator {
   private generator: CardGenerator;
   private filters: CardFilter[];
 
+  /**
+   * Cached orchestration context. Course config and salt don't change within
+   * a page load, so we build the orchestration context once and reuse it on
+   * subsequent getWeightedCards() calls (e.g. mid-session replans).
+   *
+   * This eliminates a remote getCourseConfig() round trip per pipeline run.
+   */
+  private _cachedOrchestration: OrchestrationContext | null = null;
+
+  /**
+   * Persistent tag cache. Maps cardId → tag names.
+   *
+   * Tags are static within a session (they're set at card generation time),
+   * so we cache them across pipeline runs. On replans, many of the same cards
+   * reappear — cache hits avoid redundant remote getAppliedTagsBatch() queries.
+   */
+  private _tagCache: Map<string, string[]> = new Map();
+
+  /**
+   * One-shot replan hints. Applied after the filter chain on the next
+   * getWeightedCards() call, then cleared.
+   */
+  private _ephemeralHints: ReplanHints | null = null;
+
   /**
    * Create a new pipeline.
    *
@@ -175,6 +278,20 @@ export class Pipeline extends ContentNavigator {
       });
     // Toggle pipeline configuration logging:
     logPipelineConfig(generator, filters);
+
+    // Register for debug API access
+    registerPipelineForDebug(this);
+  }
+
+  /**
+   * Set one-shot hints for the next pipeline run.
+   * Consumed after one getWeightedCards() call, then cleared.
+   *
+   * Overrides ContentNavigator.setEphemeralHints() no-op.
+   */
+  override setEphemeralHints(hints: Record<string, unknown>): void {
+    this._ephemeralHints = hints as ReplanHints;
+    logger.info(`[Pipeline] Ephemeral hints set: ${JSON.stringify(hints)}`);
   }
 
   /**
@@ -192,12 +309,17 @@ export class Pipeline extends ContentNavigator {
    * @returns Cards sorted by score descending
    */
   async getWeightedCards(limit: number): Promise<WeightedCard[]> {
+    const t0 = performance.now();
+
     // Build shared context once
     const context = await this.buildContext();
+    const tContext = performance.now();
 
-    // Over-fetch from generator to account for filtering
-    const overFetchMultiplier = 2 + this.filters.length * 0.5;
-    const fetchLimit = Math.ceil(limit * overFetchMultiplier);
+    // Over-fetch from generator to give filters a wide candidate pool.
+    // With local course DB the cost is negligible (~20ms for 500 cards).
+    // Filters (hierarchy, letter gating, etc.) can be aggressive — a wide
+    // pool ensures enough well-indicated candidates survive.
+    const fetchLimit = 500;
 
     logger.debug(
       `[Pipeline] Fetching ${fetchLimit} candidates from generator '${this.generator.name}'`
@@ -205,6 +327,7 @@ export class Pipeline extends ContentNavigator {
 
     // Get candidates from generator, passing context
     let cards = await this.generator.getWeightedCards(fetchLimit, context);
+    const tGenerate = performance.now();
     const generatedCount = cards.length;
     
     // Capture generator breakdown for debugging (if CompositeGenerator)
@@ -239,6 +362,7 @@ export class Pipeline extends ContentNavigator {
 
     // Batch hydrate tags before filters run
     cards = await this.hydrateTags(cards);
+    const tHydrate = performance.now();
     
     // Keep a copy of all cards for debug capture (before filtering removes any)
     const allCardsBeforeFiltering = [...cards];
@@ -268,12 +392,26 @@ export class Pipeline extends ContentNavigator {
     // Remove zero-score cards (hard filtered)
     cards = cards.filter((c) => c.score > 0);
 
+    // Apply ephemeral hints (one-shot, post-filter)
+    const hints = this._ephemeralHints;
+    if (hints) {
+      this._ephemeralHints = null; // consume
+      cards = this.applyHints(cards, hints, allCardsBeforeFiltering);
+    }
+
     // Sort by score descending
     cards.sort((a, b) => b.score - a.score);
 
     // Return top N
+    const tFilter = performance.now();
     const result = cards.slice(0, limit);
 
+    logger.info(
+      `[Pipeline:timing] total=${(tFilter - t0).toFixed(0)}ms ` +
+      `(context=${(tContext - t0).toFixed(0)} generate=${(tGenerate - tContext).toFixed(0)} ` +
+      `hydrate=${(tHydrate - tGenerate).toFixed(0)} filter=${(tFilter - tHydrate).toFixed(0)})`
+    );
+
     // Toggle execution summary logging:
     const topScores = result.slice(0, 3).map((c) => c.score);
     logExecutionSummary(
@@ -285,6 +423,9 @@ export class Pipeline extends ContentNavigator {
       filterImpacts
     );
 
+    // Toggle verbose result listing:
+    logResultCards(result);
+
     // Toggle provenance logging (shows scoring history for top cards):
     logCardProvenance(result, 3);
 
@@ -316,6 +457,10 @@ export class Pipeline extends ContentNavigator {
    * to the WeightedCard objects. Filters can then use card.tags instead of
    * making individual getAppliedTags() calls.
    *
+   * Uses a persistent tag cache across pipeline runs — tags are static within
+   * a session, so cards seen in a prior run (e.g. before a replan) don't
+   * require a second DB query.
+   *
    * @param cards - Cards to hydrate
    * @returns Cards with tags populated
    */
@@ -324,18 +469,153 @@ export class Pipeline extends ContentNavigator {
       return cards;
     }
 
-    const cardIds = cards.map((c) => c.cardId);
-    const tagsByCard = await this.course!.getAppliedTagsBatch(cardIds);
+    // Separate cards with cached tags from those needing a DB query
+    const uncachedIds: string[] = [];
+    for (const card of cards) {
+      if (!this._tagCache.has(card.cardId)) {
+        uncachedIds.push(card.cardId);
+      }
+    }
+
+    // Only query the DB for cards not already in cache
+    if (uncachedIds.length > 0) {
+      const freshTags = await this.course!.getAppliedTagsBatch(uncachedIds);
+      for (const [cardId, tags] of freshTags) {
+        this._tagCache.set(cardId, tags);
+      }
+    }
+
+    // Build the tagsByCard map from cache (for logging compatibility)
+    const tagsByCard = new Map<string, string[]>();
+    for (const card of cards) {
+      tagsByCard.set(card.cardId, this._tagCache.get(card.cardId) ?? []);
+    }
 
     // Toggle tag hydration logging:
     logTagHydration(cards, tagsByCard);
 
     return cards.map((card) => ({
       ...card,
-      tags: tagsByCard.get(card.cardId) ?? [],
+      tags: this._tagCache.get(card.cardId) ?? [],
     }));
   }
 
+  // ---------------------------------------------------------------------------
+  // Ephemeral hints application
+  // ---------------------------------------------------------------------------
+
+  /**
+   * Apply one-shot replan hints to the post-filter card set.
+   *
+   * Order of operations:
+   *   1. Exclude (remove unwanted cards)
+   *   2. Boost (multiply scores)
+   *   3. Require (inject must-have cards from the full pre-filter pool)
+   *
+   * @param cards - Post-filter cards (score > 0)
+   * @param hints - The ephemeral hints to apply
+   * @param allCards - Full pre-filter card pool (for require injection)
+   */
+  private applyHints(
+    cards: WeightedCard[],
+    hints: ReplanHints,
+    allCards: WeightedCard[]
+  ): WeightedCard[] {
+    const beforeCount = cards.length;
+
+    // 1. Exclude
+    if (hints.excludeCards?.length) {
+      cards = cards.filter(
+        (c) => !hints.excludeCards!.some((pat) => globMatch(c.cardId, pat))
+      );
+    }
+    if (hints.excludeTags?.length) {
+      cards = cards.filter(
+        (c) => !hints.excludeTags!.some((pat) => cardMatchesTagPattern(c, pat))
+      );
+    }
+
+    // 2. Boost
+    if (hints.boostTags) {
+      for (const [pattern, factor] of Object.entries(hints.boostTags)) {
+        for (const card of cards) {
+          if (cardMatchesTagPattern(card, pattern)) {
+            card.score *= factor;
+            card.provenance.push({
+              strategy: 'ephemeralHint',
+              strategyId: 'ephemeral-hint',
+              strategyName: 'Replan Hint',
+              action: 'boosted',
+              score: card.score,
+              reason: `boostTag ${pattern} ×${factor}`,
+            });
+          }
+        }
+      }
+    }
+    if (hints.boostCards) {
+      for (const [pattern, factor] of Object.entries(hints.boostCards)) {
+        for (const card of cards) {
+          if (globMatch(card.cardId, pattern)) {
+            card.score *= factor;
+            card.provenance.push({
+              strategy: 'ephemeralHint',
+              strategyId: 'ephemeral-hint',
+              strategyName: 'Replan Hint',
+              action: 'boosted',
+              score: card.score,
+              reason: `boostCard ${pattern} ×${factor}`,
+            });
+          }
+        }
+      }
+    }
+
+    // 3. Require — inject from the full pool if not already present
+    const cardIds = new Set(cards.map((c) => c.cardId));
+    const inject = (card: WeightedCard, reason: string) => {
+      if (!cardIds.has(card.cardId)) {
+        // Give required cards a floor score so they sort above zero-score filler
+        const floorScore = Math.max(card.score, 1.0);
+        cards.push({
+          ...card,
+          score: floorScore,
+          provenance: [
+            ...card.provenance,
+            {
+              strategy: 'ephemeralHint',
+              strategyId: 'ephemeral-hint',
+              strategyName: 'Replan Hint',
+              action: 'boosted',
+              score: floorScore,
+              reason,
+            },
+          ],
+        });
+        cardIds.add(card.cardId);
+      }
+    };
+
+    if (hints.requireCards?.length) {
+      for (const pattern of hints.requireCards) {
+        for (const card of allCards) {
+          if (globMatch(card.cardId, pattern)) inject(card, `requireCard ${pattern}`);
+        }
+      }
+    }
+    if (hints.requireTags?.length) {
+      for (const pattern of hints.requireTags) {
+        for (const card of allCards) {
+          if (cardMatchesTagPattern(card, pattern)) inject(card, `requireTag ${pattern}`);
+        }
+      }
+    }
+
+    logger.info(`[Pipeline] Hints applied: ${beforeCount} → ${cards.length} cards`);
+
+    return cards;
+  }
+
   /**
    * Build shared context for generator and filters.
    *
@@ -355,8 +635,13 @@ export class Pipeline extends ContentNavigator {
       logger.debug(`[Pipeline] Could not get user ELO, using default: ${e}`);
     }
 
-    // Initialize orchestration context (used for evolutionary weighting)
-    const orchestration = await createOrchestrationContext(this.user!, this.course!);
+    // Reuse cached orchestration context if available (course config is stable
+    // within a page load). This avoids a remote getCourseConfig() call on
+    // subsequent pipeline runs (e.g. mid-session replans).
+    if (!this._cachedOrchestration) {
+      this._cachedOrchestration = await createOrchestrationContext(this.user!, this.course!);
+    }
+    const orchestration = this._cachedOrchestration;
 
     return {
       user: this.user!,
@@ -413,4 +698,124 @@ export class Pipeline extends ContentNavigator {
 
     return [...new Set(ids)];
   }
+
+  // ---------------------------------------------------------------------------
+  // Card-space diagnostic
+  // ---------------------------------------------------------------------------
+
+  /**
+   * Scan every card in the course through the filter chain and report
+   * how many are "well indicated" (score >= threshold) for the current user.
+   *
+   * Also reports how many well-indicated cards the user has NOT yet encountered.
+   *
+   * Exposed via `window.skuilder.pipeline.diagnoseCardSpace()`.
+   */
+  async diagnoseCardSpace(opts?: { threshold?: number }): Promise<CardSpaceDiagnosis> {
+    const THRESHOLD = opts?.threshold ?? 0.10;
+    const t0 = performance.now();
+
+    // 1. Get all card IDs
+    const allCardIds = await this.course!.getAllCardIds();
+
+    // 2. Build dummy WeightedCards (score=1.0, no provenance)
+    let cards: WeightedCard[] = allCardIds.map((cardId) => ({
+      cardId,
+      courseId: this.course!.getCourseID(),
+      score: 1.0,
+      provenance: [],
+    }));
+
+    // 3. Hydrate tags
+    cards = await this.hydrateTags(cards);
+
+    // 4. Run through filters
+    const context = await this.buildContext();
+    const filterBreakdown: Array<{ name: string; wellIndicated: number }> = [];
+
+    // Track cumulative filter effects
+    for (const filter of this.filters) {
+      cards = await filter.transform(cards, context);
+      const wi = cards.filter((c) => c.score >= THRESHOLD).length;
+      filterBreakdown.push({ name: filter.name, wellIndicated: wi });
+    }
+
+    // 5. Count well-indicated
+    const wellIndicated = cards.filter((c) => c.score >= THRESHOLD);
+    const wellIndicatedIds = new Set(wellIndicated.map((c) => c.cardId));
+
+    // 6. Get encountered cards
+    let encounteredIds: Set<string>;
+    try {
+      const courseId = this.course!.getCourseID();
+      const seenCards = await this.user!.getSeenCards(courseId);
+      encounteredIds = new Set(seenCards);
+    } catch {
+      encounteredIds = new Set();
+    }
+
+    const wellIndicatedNew = wellIndicated.filter((c) => !encounteredIds.has(c.cardId));
+
+    // 7. Group by card type
+    const byType = new Map<string, { total: number; wellIndicated: number; new: number }>();
+    for (const card of cards) {
+      const type = card.cardId.split('-')[1] || 'unknown'; // c-ws-... → ws, c-intro-... → intro, etc.
+      if (!byType.has(type)) {
+        byType.set(type, { total: 0, wellIndicated: 0, new: 0 });
+      }
+      const entry = byType.get(type)!;
+      entry.total++;
+      if (card.score >= THRESHOLD) {
+        entry.wellIndicated++;
+        if (!encounteredIds.has(card.cardId)) entry.new++;
+      }
+    }
+
+    const elapsed = performance.now() - t0;
+
+    const result: CardSpaceDiagnosis = {
+      totalCards: allCardIds.length,
+      threshold: THRESHOLD,
+      wellIndicated: wellIndicatedIds.size,
+      encountered: encounteredIds.size,
+      wellIndicatedNew: wellIndicatedNew.length,
+      byType: Object.fromEntries(byType),
+      filterBreakdown,
+      elapsedMs: Math.round(elapsed),
+    };
+
+    // Log to console
+    logger.info(`[Pipeline:diagnose] Card space scan (${result.elapsedMs}ms):`);
+    logger.info(`[Pipeline:diagnose]   Total cards: ${result.totalCards}`);
+    logger.info(`[Pipeline:diagnose]   Well-indicated (score >= ${THRESHOLD}): ${result.wellIndicated}`);
+    logger.info(`[Pipeline:diagnose]   Encountered: ${result.encountered}`);
+    logger.info(`[Pipeline:diagnose]   Well-indicated & new: ${result.wellIndicatedNew}`);
+    logger.info(`[Pipeline:diagnose]   By type:`);
+    for (const [type, counts] of byType) {
+      logger.info(
+        `[Pipeline:diagnose]     ${type}: ${counts.wellIndicated}/${counts.total} well-indicated, ${counts.new} new`
+      );
+    }
+    logger.info(`[Pipeline:diagnose]   After each filter:`);
+    for (const fb of filterBreakdown) {
+      logger.info(`[Pipeline:diagnose]     ${fb.name}: ${fb.wellIndicated} well-indicated`);
+    }
+
+    return result;
+  }
+
+}
+
+/**
+ * Diagnosis of the full card space for the current user.
+ */
+export interface CardSpaceDiagnosis {
+  totalCards: number;
+  threshold: number;
+  wellIndicated: number;
+  encountered: number;
+  wellIndicatedNew: number;
+  byType: Record<string, { total: number; wellIndicated: number; new: number }>;
+  filterBreakdown: Array<{ name: string; wellIndicated: number }>;
+  elapsedMs: number;
 }

package/src/core/navigators/PipelineAssembler.ts

@@ -1,5 +1,5 @@
 import type { ContentNavigationStrategyData } from '../types/contentNavigationStrategy';
-import { ContentNavigator, isGenerator, isFilter } from './index';
+import { ContentNavigator, isGenerator, isFilter, Navigators } from './index';
 import type { CardFilter } from './filters/types';
 import { WeightedFilter } from './filters/WeightedFilter';
 import type { CardGenerator } from './generators/types';
@@ -103,24 +103,29 @@ export class PipelineAssembler {
       }
     }
 
-    // If no generator but filters exist, use default ELO and SRS generators
+    // Always ensure ELO and SRS generators are present.
+    // Custom generators (e.g., prescribed) supplement but don't replace them.
+    const courseId = course.getCourseID();
+    const hasElo = generatorStrategies.some((s) => s.implementingClass === Navigators.ELO);
+    const hasSrs = generatorStrategies.some((s) => s.implementingClass === Navigators.SRS);
+
+    if (!hasElo) {
+      logger.debug('[PipelineAssembler] No ELO generator configured, adding default');
+      generatorStrategies.push(createDefaultEloStrategy(courseId));
+    }
+    if (!hasSrs) {
+      logger.debug('[PipelineAssembler] No SRS generator configured, adding default');
+      generatorStrategies.push(createDefaultSrsStrategy(courseId));
+    }
+
     if (generatorStrategies.length === 0) {
-      if (filterStrategies.length > 0) {
-        logger.debug(
-          '[PipelineAssembler] No generator found, using default ELO and SRS with configured filters'
-        );
-        const courseId = course.getCourseID();
-        generatorStrategies.push(createDefaultEloStrategy(courseId));
-        generatorStrategies.push(createDefaultSrsStrategy(courseId));
-      } else {
-        warnings.push('No generator strategy found');
-        return {
-          pipeline: null,
-          generatorStrategies: [],
-          filterStrategies: [],
-          warnings,
-        };
-      }
+      warnings.push('No generator strategy found');
+      return {
+        pipeline: null,
+        generatorStrategies: [],
+        filterStrategies: [],
+        warnings,
+      };
     }
 
     // Instantiate generators