@vue-skuilder/db 0.2.7 → 0.2.9

package/docs/navigators-architecture.md

@@ -18,7 +18,7 @@ A card with a suitability score, audit trail, and pre-fetched metadata:
 interface WeightedCard {
   cardId: string;
   courseId: string;
-  score: number;              // 0-1 suitability score
+  score: number;              // suitability; anchored at [0,1] but unbounded above (see Score Semantics)
   provenance: StrategyContribution[];  // Audit trail
   tags?: string[];            // Pre-fetched tags (hydrated by Pipeline)
 }
@@ -47,17 +47,21 @@ interface CardGenerator {
 
 **Implementations:**
 - `ELONavigator` — New cards scored by ELO proximity to user skill (scores 0.0-1.0)
-- `SRSNavigator` — Review cards scored by overdueness, interval recency, and **backlog pressure** (scores 0.5-1.0)
-- `HardcodedOrderNavigator` — Fixed sequence defined by course author // NB this no longer exists but /home/colin/pn/vue-skuilder/master/packages/db/src/core/navigators/generators/prescribed.ts does - please update the doc in place
+- `SRSNavigator` — Review cards scored by overdueness, interval recency, and a multiplicative **backlog pressure** (base urgency ~0.5–0.95, scaled up by the backlog multiplier — can exceed 1.0)
+- `PrescribedCardsGenerator` — Stateful generator for authored, course-prescribed content (e.g. intro cards that must eventually surface). Tracks whether prescribed targets have been encountered, applies progressive pressure to stale/pending target groups, can emit upstream support cards to satisfy prereqs of still-blocked targets, and drills unlocked-but-under-practiced skills under a **practice-debt pressure** (base ×2 escalating with debt age, capped — a persistent, self-discharging analog of SRS backlog pressure that guarantees a minimum number of reps land after intro). Registered as `prescribed`. See `generators/prescribed.ts`.
 - `CompositeGenerator` — Merges multiple generators with frequency boost
 
 #### SRS Backlog Pressure
 
-The SRS generator implements a self-regulating **backlog pressure** mechanism that prevents review pile-up while maintaining healthy new/review balance:
+The SRS generator implements a self-regulating **backlog pressure** mechanism that prevents review pile-up while maintaining healthy new/review balance.
 
-- **Healthy backlog** (≤20 due reviews): No pressure boost, scores 0.5-0.95. New content (ELO) naturally dominates.
-- **Elevated backlog** (40 due): +0.25 boost, scores 0.75-1.0. Reviews compete with new cards.
-- **High backlog** (60+ due): +0.50 boost (max), scores 0.95-1.0. Reviews take priority.
+Each review's per-card urgency is `base 0.5 + (overdueness/recency factors)·0.45` → ~0.5–0.95. Backlog pressure then **multiplies** that urgency by a global factor that grows as the due pile exceeds the healthy threshold (default `MAX_BACKLOG_MULTIPLIER = 2.0`, reached at 3× healthy):
+
+- **Healthy backlog** (≤20 due reviews): ×1.0 — no boost, scores ~0.5–0.95. New content (ELO) naturally dominates.
+- **Elevated backlog** (40 due): ×1.5 — scores ~0.85–1.4. Reviews compete with new cards.
+- **High backlog** (60+ due): ×2.0 (max) — scores ~1.1–1.9. Reviews take priority.
+
+**Why multiplicative, and not clamped to 1.0:** review scores are *not* capped at 1.0. They are designed to be cross-comparable with new-card scores, which are themselves no longer [0,1]-bounded — session hints multiply scores (an intro can boost its exercise tag ×5+), and `SessionController` draws one rank-ordered supply queue where reviews and new compete on a single open scale (see `decision-single-supply-queue.md`). A flat additive `+0.5` (the previous design) was both too small to contend with such boosts and largely swallowed by the old 1.0 clamp. A bounded multiplier scales review priority onto the same open scale, so a heavy backlog can genuinely lift reviews into contention; the cap (not a score ceiling) is what keeps them from running away.
 
 This treats SRS scheduling times as **eligibility dates** rather than hard due dates—reviewing slightly later may be optimal. The system maintains a healthy backlog rather than always clearing to zero (avoiding "Anki death spiral").
 
@@ -66,7 +70,7 @@ Configuration via strategy `serializedData`:
 { "healthyBacklog": 20 }
 ```
 
-See `todo-review-adaptation.md` for planned per-user adaptation extensions.
+`MAX_BACKLOG_MULTIPLIER` is currently a module constant in `generators/srs.ts` (tune against the dbg overlay's "review backpressure" panel). See `todo-review-adaptation.md` for planned per-user adaptation extensions.
 
 ### CardFilter
 
@@ -200,10 +204,14 @@ Pipeline(
 
 | Score | Meaning |
 |-------|---------|
-| 1.0 | Fully suitable |
+| 1.0 | Fully suitable (the generator anchor, **not** a ceiling) |
 | 0.5 | Neutral |
 | 0.0 | Exclude (hard filter) |
 | 0.x | Proportional suitability |
+| >1.0 | Boosted / elevated-urgency — above the nominal "fully suitable" anchor |
+| +INF | Mandatory — a required card injected by a `requireCards`/`requireTags` hint |
+
+**1.0 is an anchor, not a cap.** Generators emit in ~[0,1], but the final score is an *open* scale: multiplicative filters and session hints can push scores above 1.0 (an intro boosting its exercise tag ×5), and the SRS backlog multiplier lifts urgent reviews past 1.0 under heavy backlog. This is deliberate — it lets reviews and new cards compete on one cross-comparable scale, which is what `SessionController`'s single supply queue draws against (see `decision-single-supply-queue.md`). `+INF` is the require-injection sentinel; such cards float to the head of the supply.
 
 **All filters are multipliers.** This means:
 - Filter order doesn't affect final scores (multiplication is commutative)
@@ -531,8 +539,15 @@ class MyFilter extends ContentNavigator implements CardFilter {
 ```
 
 This enables **single source of truth** patterns: the consumer app writes state
-via `UsrCrsDataInterface.putStrategyState()`, and the consumer filter reads it
-via the same key. No framework changes needed.
+through the course-scoped interface, which is reached via the **async**
+`getCourseInterface(courseId)` (await it first — it returns a `Promise`):
+
+```typescript
+const courseDb = await userDB.getCourseInterface(courseId);
+await courseDb.putStrategyState<MyStateType>('MySharedStateKey', data);
+```
+
+The consumer filter then reads it via the same key. No framework changes needed.
 
 ---
 
@@ -633,8 +648,9 @@ return { ...card, score: card.score * multiplier };
 | `core/navigators/PipelineAssembler.ts` | Builds Pipeline from strategy docs |
 | `core/navigators/CompositeGenerator.ts` | Merges multiple generators |
 | `core/navigators/generators/elo.ts` | ELO generator |
-| `core/navigators/generators/srs.ts` | SRS generator (with backlog pressure) |
-| `core/navigators/hardcodedOrder.ts` | Fixed-order generator |
+| `core/navigators/generators/srs.ts` | SRS generator (multiplicative backlog pressure) |
+| `core/navigators/generators/prescribed.ts` | Prescribed-content generator (authored targets, support cards, practice drilling) |
+| `core/navigators/SrsDebugger.ts` | Per-run SRS backlog capture for the session overlay |
 | `core/navigators/hierarchyDefinition.ts` | Prerequisite filter |
 | `core/navigators/interferenceMitigator.ts` | Interference filter |
 | `core/navigators/relativePriority.ts` | Priority filter |

package/package.json

@@ -4,7 +4,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "0.2.7",
+  "version": "0.2.9",
   "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.2.7",
+    "@vue-skuilder/common": "0.2.9",
     "cross-fetch": "^4.1.0",
     "moment": "^2.29.4",
     "pouchdb": "^9.0.0",
@@ -62,5 +62,5 @@
     "vite": "^8.0.0",
     "vitest": "^4.1.0"
   },
-  "stableVersion": "0.2.7"
+  "stableVersion": "0.2.9"
 }

package/src/core/interfaces/contentSource.ts

@@ -40,6 +40,13 @@ export interface StudySessionItem {
   cardID: string;
   courseID: string;
   elo?: number;
+  /**
+   * Pipeline suitability score at queue-build time, carried for observability
+   * (the debug overlay renders the now-load-bearing supply ranking). `+INF`
+   * marks a mandatory required card. Not used for any draw decision — the
+   * supplyQ is already ordered, so the controller draws front-to-back.
+   */
+  score?: number;
   // reviewID?: string;
 }
 

package/src/core/navigators/Pipeline.ts

@@ -255,7 +255,22 @@ function logCardProvenance(cards: WeightedCard[], maxCards: number = 3): void {
  * const cards = await pipeline.getWeightedCards(20);
  * ```
  */
-export class Pipeline extends ContentNavigator {
+
+/**
+ * Narrow capability surface for out-of-band, commit-free reads against a live
+ * pipeline (see {@link getActivePipeline}). Kept minimal on purpose — consumers
+ * get the forecast capability, not the whole `Pipeline` class.
+ */
+export interface PipelineForecaster {
+  forecast(opts?: {
+    hints?: ReplanHints;
+    unseenOnly?: boolean;
+    threshold?: number;
+    limit?: number;
+  }): Promise<WeightedCard[]>;
+}
+
+export class Pipeline extends ContentNavigator implements PipelineForecaster {
   private generator: CardGenerator;
   private filters: CardFilter[];
 
@@ -890,6 +905,83 @@ export class Pipeline extends ContentNavigator {
   // Card-space diagnostic
   // ---------------------------------------------------------------------------
 
+  /**
+   * Commit-free forecast: score the user's full card space through the filter
+   * chain and return the cards that are currently *reachable* (score >=
+   * threshold), optionally nudged by caller-supplied hints and/or restricted
+   * to cards the user hasn't seen yet.
+   *
+   * This is a GENERIC primitive — it returns scored, tag-hydrated cards and
+   * stops there. It has no knowledge of any particular tag convention; callers
+   * decide what the surviving cards mean (e.g. filter to their own "intro"
+   * tag family). Nothing is written and no session is started.
+   *
+   * The optional `hints` are the "out-of-band kick": they run through the same
+   * {@link applyHints} path a live replan uses, so the two semantics carry over —
+   *   - `boostTags`/`boostCards` reweight *within* gating (a gated score-0 card
+   *     stays out), and
+   *   - `requireTags`/`requireCards` inject from the full pre-filter pool,
+   *     *bypassing* gating (use when you want a card regardless of reachability).
+   * Note `unseenOnly` is applied LAST, so it can drop a `require`d card that the
+   * user has already seen — pass `unseenOnly: false` if that matters.
+   *
+   * Cost note: like {@link diagnoseCardSpace}, this scans every card through the
+   * filters, so it's heavier than a normal replan. Intended for one-shot
+   * out-of-band use (e.g. a session-end "what's next" snapshot), not the hot path.
+   *
+   * @param opts.hints       Optional ephemeral hints to apply after the filter chain.
+   * @param opts.unseenOnly  Only return cards the user hasn't encountered (default true).
+   * @param opts.threshold   Min score to count as reachable (default 0.10).
+   * @param opts.limit       Optional cap on results (already sorted desc).
+   */
+  async forecast(opts?: {
+    hints?: ReplanHints;
+    unseenOnly?: boolean;
+    threshold?: number;
+    limit?: number;
+  }): Promise<WeightedCard[]> {
+    const threshold = opts?.threshold ?? 0.10;
+    const unseenOnly = opts?.unseenOnly ?? true;
+
+    const courseId = this.course!.getCourseID();
+    const allCardIds = await this.course!.getAllCardIds();
+
+    let cards: WeightedCard[] = allCardIds.map((cardId) => ({
+      cardId,
+      courseId,
+      score: 1.0,
+      provenance: [],
+    }));
+
+    cards = await this.hydrateTags(cards);
+    // Snapshot the full pool before filtering, for require-injection in applyHints.
+    const fullPool = cards.slice();
+
+    const context = await this.buildContext();
+    for (const filter of this.filters) {
+      cards = await filter.transform(cards, context);
+    }
+
+    if (opts?.hints) {
+      cards = this.applyHints(cards, opts.hints, fullPool);
+    }
+
+    cards = cards.filter((c) => c.score >= threshold);
+
+    if (unseenOnly) {
+      let encountered: Set<string>;
+      try {
+        encountered = new Set(await this.user!.getSeenCards(courseId));
+      } catch {
+        encountered = new Set();
+      }
+      cards = cards.filter((c) => !encountered.has(c.cardId));
+    }
+
+    cards.sort((a, b) => b.score - a.score);
+    return opts?.limit ? cards.slice(0, opts.limit) : cards;
+  }
+
   /**
    * Scan every card in the course through the filter chain and report
    * how many are "well indicated" (score >= threshold) for the current user.

package/src/core/navigators/PipelineDebugger.ts

@@ -8,7 +8,7 @@ import {
   isFilter,
 } from './index';
 import { logger } from '../../util/logger';
-import type { Pipeline, CardSpaceDiagnosis } from './Pipeline';
+import type { Pipeline, CardSpaceDiagnosis, PipelineForecaster } from './Pipeline';
 import type { ReplanHints } from './generators/types';
 
 /**
@@ -25,6 +25,16 @@ export function registerPipelineForDebug(pipeline: Pipeline): void {
   _activePipeline = pipeline;
 }
 
+/**
+ * The most recently constructed pipeline for the current session, or null if
+ * none has been built yet. This is the supported, non-debug accessor for
+ * out-of-band reads against the live pipeline (e.g. a commit-free
+ * `forecast()`), replacing reach-ins through `window.skuilder.pipeline`.
+ */
+export function getActivePipeline(): PipelineForecaster | null {
+  return _activePipeline;
+}
+
 // ============================================================================
 // PIPELINE DEBUGGER
 // ============================================================================

package/src/core/navigators/SrsDebugger.ts

@@ -0,0 +1,53 @@
+// ============================================================================
+// SRS BACKLOG DEBUGGER
+// ============================================================================
+//
+// A tiny module-level capture of the SRS generator's per-run backlog state,
+// so the live session overlay can show whether reviews being out-competed by
+// (boosted) new cards is *temporary* (the backlog multiplier still has headroom
+// to climb and lift reviews) or *boost-driven* (the multiplier is maxed and the
+// new-card boosts simply sit higher — only a hint relaxation reorders them).
+//
+// Mirrors MixerDebugger/PipelineDebugger: the generator pushes a snapshot each
+// run (keyed by course, latest wins); the overlay reads it via the controller's
+// getDebugSnapshot(). No DB load on the read path.
+//
+// ============================================================================
+
+/** Per-course snapshot of SRS backlog state, captured on each SRS generator run. */
+export interface SrsBacklogDebug {
+  courseId: string;
+  /** Total reviews scheduled for this course (due + not-yet-due). */
+  scheduledTotal: number;
+  /** Reviews eligible (due) right now. */
+  dueNow: number;
+  /** Healthy backlog threshold; multiplier is ×1.0 at or below this. */
+  healthyBacklog: number;
+  /** Global multiplier applied to every due review's urgency this run (1.0 → max). */
+  backlogMultiplier: number;
+  /** Max achievable backlog multiplier (the cap), for headroom context. */
+  maxBacklogMultiplier: number;
+  /** Highest review score produced this run (post-multiplier; can exceed 1.0); null if none due. */
+  topReviewScore: number | null;
+  /** Human-readable time until the next review comes due, or null if some are due now. */
+  nextDueIn: string | null;
+  /** Epoch ms of capture. */
+  timestamp: number;
+}
+
+const snapshots = new Map<string, SrsBacklogDebug>();
+
+/** Called by the SRS generator once per run. Latest snapshot per course wins. */
+export function captureSrsBacklog(snapshot: SrsBacklogDebug): void {
+  snapshots.set(snapshot.courseId, snapshot);
+}
+
+/** Current backlog snapshot for every course seen, newest-first. */
+export function getSrsBacklogDebug(): SrsBacklogDebug[] {
+  return [...snapshots.values()].sort((a, b) => b.timestamp - a.timestamp);
+}
+
+/** Drop all captured snapshots (called on session start, alongside pipeline history). */
+export function clearSrsBacklogDebug(): void {
+  snapshots.clear();
+}

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

@@ -79,6 +79,14 @@ interface GroupCardState {
 interface PrescribedProgressState {
   updatedAt: string;
   groups: Record<string, GroupCardState>;
+  /**
+   * Per-practice-tag debt age: tag → ISO timestamp when the skill first appeared
+   * unlocked-but-under-practiced. Drives the practice-debt staleness escalation
+   * (older unpaid debt → higher pressure). An entry is carried while the debt is
+   * open and dropped the moment the skill reaches `practiceMinCount` — so the
+   * map self-prunes and "staleness" is measured from first-owed, not last-seen.
+   */
+  practiceDebt?: Record<string, string>;
 }
 
 interface TagPrerequisite {
@@ -126,10 +134,20 @@ const DEFAULT_MAX_PRACTICE_PER_RUN = 4;
 const BASE_TARGET_SCORE = 1.0;
 const BASE_SUPPORT_SCORE = 0.8;
 const DISCOVERED_SUPPORT_SCORE = 12.0;
-// Practice drill cards enter the pool at parity with a well-matched target so
-// they survive into the candidate set; per-skill *emphasis* (recency, decay) is
-// the durable boost's job, not this base score's.
+// Practice drill cards: a *practice-debt pressure*, parallel to the SRS backlog
+// multiplier. An unlocked-but-under-practiced skill owes reps; that debt is
+// durable (keyed off per-tag attempt count) and discharges by practice, not
+// time. The score is base × a debt multiplier that starts at PRACTICE_BASE_MULT
+// (so a few reps land promptly after intro, competing with pressured reviews)
+// and escalates by how long the debt has stayed open (capped), so a chronically
+// out-competed skill eventually forces exposure rather than competing at flat
+// parity forever. Replaces the old flat 1.0, which punted emphasis to the
+// session-scoped intro boost that evaporates at session end.
 const BASE_PRACTICE_SCORE = 1.0;
+const PRACTICE_BASE_MULT = 2.0;
+const MAX_PRACTICE_MULTIPLIER = 4.0;
+// Added to the multiplier per day the debt stays open (linear, then clamped).
+const PRACTICE_STALENESS_BUMP_PER_DAY = 0.5;
 const MAX_TARGET_MULTIPLIER = 8.0;
 const MAX_SUPPORT_MULTIPLIER = 4.0;
 
@@ -271,6 +289,10 @@ export default class PrescribedCardsGenerator extends ContentNavigator implement
     const emitted: WeightedCard[] = [];
     const emittedIds = new Set<string>();
     const groupRuntimes: GroupRuntimeState[] = [];
+    // Practice-debt ages carried forward: stamped when a skill first appears
+    // under-practiced, dropped once it's discharged (see buildPracticeCards).
+    const priorPracticeDebt = progress.practiceDebt ?? {};
+    const nextPracticeDebt: Record<string, string> = {};
 
     for (const group of this.config.groups) {
       const runtime = this.buildGroupRuntimeState({
@@ -346,11 +368,17 @@ export default class PrescribedCardsGenerator extends ContentNavigator implement
         userGlobalElo,
         activeIds,
         seenIds,
+        priorPracticeDebt,
+        nextPracticeDebt,
       });
 
       emitted.push(...directCards, ...supportCards, ...discoveredSupportCards, ...practiceCards);
     }
 
+    // Persist the carried-forward practice debt (self-pruned: discharged skills
+    // simply aren't re-stamped above, so they drop out of the next state).
+    nextState.practiceDebt = nextPracticeDebt;
+
     const hintSummary = this.buildSupportHintSummary(groupRuntimes);
     const hints: ReplanHints | undefined =
       Object.keys(hintSummary.boostTags).length > 0
@@ -821,9 +849,16 @@ export default class PrescribedCardsGenerator extends ContentNavigator implement
    * `practiceMinCount`), this resolves cards carrying that tag and emits them
    * into the candidate pool. It exists because global-ELO retrieval
    * systematically fails to fetch the (low-ELO) drill cards for a
-   * freshly-introduced skill — putting them in the pool here lets the pipeline's
-   * scoring + the durable per-skill boost order them. Ordering/emphasis is NOT
-   * this method's job; it only guarantees presence.
+   * freshly-introduced skill — putting them in the pool here guarantees presence.
+   *
+   * Emphasis is a **practice-debt pressure** (parallel to SRS backlog pressure):
+   * cards score `base × multiplier`, where the multiplier starts at
+   * PRACTICE_BASE_MULT (so a few reps land promptly post-intro, competing with
+   * pressured reviews) and escalates by how long the debt has stayed open
+   * (per-tag, time-based via `priorPracticeDebt`/`nextPracticeDebt`), clamped at
+   * MAX_PRACTICE_MULTIPLIER. The debt is durable and self-discharges the instant
+   * the skill reaches `practiceMinCount` — so this no longer relies on the
+   * session-scoped intro boost to actually surface.
    *
    * Fully data-driven: the unlock relation comes from the hierarchy config and
    * practice-status from per-tag ELO. No card-id or tag-namespace hard-coding.
@@ -838,6 +873,8 @@ export default class PrescribedCardsGenerator extends ContentNavigator implement
     userGlobalElo: number;
     activeIds: Set<string>;
     seenIds: Set<string>;
+    priorPracticeDebt: Record<string, string>;
+    nextPracticeDebt: Record<string, string>;
   }): WeightedCard[] {
     const {
       group,
@@ -849,6 +886,8 @@ export default class PrescribedCardsGenerator extends ContentNavigator implement
       userGlobalElo,
       activeIds,
       seenIds,
+      priorPracticeDebt,
+      nextPracticeDebt,
     } = args;
 
     const patterns = group.practiceTagPatterns ?? [];
@@ -866,6 +905,25 @@ export default class PrescribedCardsGenerator extends ContentNavigator implement
 
     if (practiceTags.length === 0) return [];
 
+    // Carry forward (or open) each under-practiced skill's debt age, and derive
+    // its practice multiplier: base + staleness-since-first-owed, clamped. Done
+    // for every under-practiced tag (not just emitted ones) so the debt clock
+    // keeps running even on runs where the cap or de-dup emits nothing.
+    const now = Date.now();
+    const DAY_MS = 24 * 60 * 60 * 1000;
+    const tagMultiplier = new Map<string, number>();
+    for (const tag of practiceTags) {
+      const firstOwedAt = priorPracticeDebt[tag] ?? isoNow();
+      nextPracticeDebt[tag] = firstOwedAt;
+      const staleDays = Math.max(0, (now - new Date(firstOwedAt).getTime()) / DAY_MS);
+      const mult = clamp(
+        PRACTICE_BASE_MULT + staleDays * PRACTICE_STALENESS_BUMP_PER_DAY,
+        PRACTICE_BASE_MULT,
+        MAX_PRACTICE_MULTIPLIER
+      );
+      tagMultiplier.set(tag, mult);
+    }
+
     // Reuse the diversity-aware tag→cards collector (stem-dedup + shuffle).
     const practiceCardIds = this.findDiscoveredSupportCards({
       supportTags: practiceTags,
@@ -886,19 +944,28 @@ export default class PrescribedCardsGenerator extends ContentNavigator implement
     const cards: WeightedCard[] = [];
     for (const cardId of practiceCardIds) {
       emittedIds.add(cardId);
+      // Most-stale wins: a card may carry several practice tags; take the
+      // highest debt multiplier among the ones it serves.
+      let mult = PRACTICE_BASE_MULT;
+      for (const tag of practiceTags) {
+        if ((cardsByTag.get(tag)?.includes(cardId) ?? false)) {
+          mult = Math.max(mult, tagMultiplier.get(tag) ?? PRACTICE_BASE_MULT);
+        }
+      }
+      const score = BASE_PRACTICE_SCORE * mult;
       cards.push({
         cardId,
         courseId,
-        score: BASE_PRACTICE_SCORE,
+        score,
         provenance: [
           {
             strategy: 'prescribed',
             strategyName: this.strategyName || this.name,
             strategyId: this.strategyId || 'NAVIGATION_STRATEGY-prescribed',
             action: 'generated' as const,
-            score: BASE_PRACTICE_SCORE,
+            score,
             reason:
-              `mode=practice;group=${group.id};` +
+              `mode=practice;group=${group.id};debtMult=×${mult.toFixed(2)};` +
               `underPracticedSkills=${practiceTags.length};` +
               `practiceTags=${practiceTags.slice(0, 8).join('|')}${practiceTags.length > 8 ? '|…' : ''};` +
               `testversion=${PRESCRIBED_DEBUG_VERSION}`,