@orakl/shared 0.1.0 → 0.3.0

package/dist/badges.d.ts

@@ -32,6 +32,20 @@ export type BadgeContext = {
     score: number;
     /** Questions actually served in this game. */
     questionsServed: number;
+    /** Rounds this player was right while most of the field was wrong (Cassandra). */
+    fieldRoundsDefied?: number;
+    /** Rounds this player alone was right with the field answering (Lone torch). */
+    soleCorrectRounds?: number;
+    /**
+     * This player's rank after each closed round, with the field size then
+     * and whether their score was strictly above everyone else's; null for
+     * rounds before they held a hero slot (Ascendant, Undisputed).
+     */
+    rankHistory?: Array<{
+        rank: number;
+        field: number;
+        lead: boolean;
+    } | null>;
 };
 export interface BadgeInput {
     context: BadgeContext;
@@ -52,22 +66,30 @@ export interface BadgeInput {
     /** Mean time-to-answer (ms) across the run. */
     timeToAnswerAvgMs: number;
     /**
-     * Best "faster than most" reading this run: the highest % of prior correct
-     * solvers any single answer beat on time. Null when no question had enough
-     * samples to judge. Drives the Faster-than-most badge (US #11).
-     */
-    fasterThanMaxPercent: number | null;
-    /**
-     * Total times the player switched a selection before committing, across the
-     * run. 0 means every answer was committed first-try (sure-handed). Undefined
-     * when the client didn't report changes (legacy) — the badge then can't award.
+     * Correct answers this run that each beat more than 75% of prior correct
+     * solvers on time (the player's own attempts excluded). Drives Wing-footed.
      */
-    answerChanges?: number;
+    fastAnswerCount: number;
     /**
      * The player's consecutive-days-played streak as of this run (signed-in only).
      * Drives the Devotee badge; undefined for guests / when not computed.
      */
     consecutiveDays?: number;
+    /** This run's total score. Drives New heights; undefined when not computed. */
+    runScore?: number;
+    /**
+     * Best score across the player's prior completed runs in this run's exact
+     * trial bucket (question count, timer, difficulty; normal mode); null when
+     * none. Drives New heights; undefined for guests / lookup failure.
+     */
+    bucketBest?: number | null;
+    /** Count of those prior runs; New heights needs at least 3. */
+    bucketPriorRuns?: number;
+    /**
+     * Distinct categories the player answered correctly across prior runs.
+     * Drives Far horizons; undefined for guests / lookup failure.
+     */
+    priorCorrectCategories?: string[];
     results: Array<{
         timeToAnswerMs: number;
         categoryId: string;
@@ -76,8 +98,27 @@ export interface BadgeInput {
         difficulty?: "easy" | "medium" | "hard";
     }>;
 }
+/** An answer beating more than this % of prior solvers counts toward Wing-footed. */
+export declare const FASTER_THAN_MOST_PERCENT = 75;
 /** Served-questions floor for the rank badges (victor, podium) and lifetime best-rank — below this a rank isn't a claim. */
 export declare const RANK_BADGE_MIN_QUESTIONS = 6;
+/** One player's row for one round of a multiplayer game's answer log. */
+export interface FieldLogEntry {
+    questionIndex: number;
+    isCorrect: boolean;
+    /** True when the player chose an answer; false for a miss-filled round. */
+    submitted: boolean;
+}
+/**
+ * Field-relative round counts for `playerId` from every tenured player's log.
+ * The field for a round is the other players' submitted answers; a miss-filled
+ * row (a leaver, or a timeout) is not a wrong answer and is left out. Round
+ * tallies are cached per `logs` map, so `logs` must not change between calls.
+ */
+export declare function fieldRoundStats(playerId: string, logs: ReadonlyMap<string, readonly FieldLogEntry[]>): {
+    fieldRoundsDefied: number;
+    soleCorrectRounds: number;
+};
 /**
  * Raw share (0–1) of answers committed before the clock's halfway mark — quick
  * answers read as decisive (implicit confidence from timing). Null when not
@@ -103,12 +144,6 @@ export declare function computeBadges(input: BadgeInput): BadgeAward[];
 export type Rarity = "common" | "rare" | "legendary" | "exotic";
 export declare const RARITY_ORDER: Rarity[];
 export declare const RARITY_LABELS: Record<Rarity, string>;
-/**
- * Canonical tier colours, shared by every surface that renders the rarity
- * scale (badge chips, legends) so the key always matches the badges it
- * explains.
- */
-export declare const RARITY_CHIP_CLASSES: Record<Rarity, string>;
 /** The rarity tier a badge reaches when earned under the given run conditions. */
 export declare function computeBadgeRarity(id: BadgeId, run: BadgeRunParams): Rarity;
 /** Parse a stored badge-id JSON array; malformed/missing/unknown ids read as none. */

package/dist/badges.js

@@ -20,24 +20,34 @@ const MULTIPLAYER_ONLY = ["multiplayer"];
 /** Display order, most prestigious first. */
 export const BADGE_ORDER = [
     "victor",
+    "undisputed",
     "flawless",
     "unstoppable",
+    "herculean",
     "on-a-roll",
     "survivor",
     "giant-slayer",
+    "ascendant",
+    "cassandra",
     "sharpshooter",
     "podium",
     "pantheon",
     "specialist",
     "polymath",
     "phoenix",
+    "far-horizons",
+    "new-heights",
     "strong-finish",
+    "strong-start",
+    "undaunted",
     "master-of-none",
     "faster-than-most",
     "clutch",
     "quick-draw",
-    "decisive",
+    "measured",
     "sure-handed",
+    "decisive",
+    "lone-torch",
     "unbroken-focus",
     "devotee",
 ];
@@ -45,21 +55,21 @@ export const BADGES = {
     victor: {
         id: "victor",
         label: "Victor",
-        description: "Topped the field in a multiplayer quiz.",
+        description: "Topped the field in a multiplayer game.",
         icon: "banner",
         modes: MULTIPLAYER_ONLY,
     },
     podium: {
         id: "podium",
         label: "Podium",
-        description: "Finished among the top three in a multiplayer quiz.",
+        description: "Finished in the top three of a multiplayer game.",
         icon: "steps",
         modes: MULTIPLAYER_ONLY,
     },
     flawless: {
         id: "flawless",
         label: "Flawless",
-        description: "Cleared a trial without a single miss.",
+        description: "Cleared a run without a single miss.",
         icon: "wreath",
         modes: CROSS_MODE,
     },
@@ -87,91 +97,91 @@ export const BADGES = {
     "giant-slayer": {
         id: "giant-slayer",
         label: "Giant slayer",
-        description: "Cleared a hard-difficulty trial with commanding accuracy.",
+        description: "Cleared a hard run with 90% accuracy or better.",
         icon: "empty-skull",
         modes: CROSS_MODE,
     },
     pantheon: {
         id: "pantheon",
         label: "Pantheon",
-        description: "Aced two or more categories in a single trial.",
+        description: "Aced two or more categories in a single run.",
         icon: "olympus",
         modes: CROSS_MODE,
     },
     phoenix: {
         id: "phoenix",
         label: "Phoenix",
-        description: "Rallied to a long streak after an early stumble.",
+        description: "Rallied to five in a row after a miss.",
         icon: "flower-1",
         modes: CROSS_MODE,
     },
     clutch: {
         id: "clutch",
         label: "Clutch",
-        description: "Landed answers in the dying moments of the clock.",
+        description: "Landed three answers in the clock's dying moments.",
         icon: "clock",
         modes: CROSS_MODE,
     },
     sharpshooter: {
         id: "sharpshooter",
         label: "Sharpshooter",
-        description: "Finished a trial with near-perfect accuracy.",
+        description: "Finished a run with 95% accuracy or better.",
         icon: "rhombus",
         modes: CROSS_MODE,
     },
     specialist: {
         id: "specialist",
         label: "Specialist",
-        description: "Aced every question in a category.",
+        description: "Aced every question in a category, four or more.",
         icon: "owl",
         modes: CROSS_MODE,
     },
     polymath: {
         id: "polymath",
         label: "Polymath",
-        description: "Answered well across easy, medium and hard in one trial.",
+        description: "Scored 60% or better on easy, medium and hard in one run.",
         icon: "scroll",
         modes: CROSS_MODE,
     },
     "strong-finish": {
         id: "strong-finish",
         label: "Strong finish",
-        description: "Closed out a trial on a long unbroken streak.",
+        description: "Closed out a run on five or more correct in a row.",
         icon: "flags",
         modes: CROSS_MODE,
     },
     "sure-handed": {
         id: "sure-handed",
         label: "Sure-handed",
-        description: "Committed every answer without second-guessing.",
+        description: "Answered four in five correctly before the clock's halfway mark.",
         icon: "check",
-        modes: SOLO_ONLY,
+        modes: CROSS_MODE,
     },
     devotee: {
         id: "devotee",
         label: "Devotee",
-        description: "Returned to the oracle on consecutive days.",
+        description: "Returned to the oracle three days running.",
         icon: "church",
         modes: SOLO_ONLY,
     },
     "master-of-none": {
         id: "master-of-none",
-        label: "Master of none",
-        description: "Earned a spread of honours across many categories at once.",
+        label: "Many-sided",
+        description: "Earned four other badges in one run spanning four or more categories.",
         icon: "dice",
         modes: CROSS_MODE,
     },
     "faster-than-most": {
         id: "faster-than-most",
-        label: "Faster than most",
-        description: "Beat most other players' time on a question.",
+        label: "Wing-footed",
+        description: "Outran most earlier solvers on three questions in one trial.",
         icon: "top-right",
         modes: SOLO_ONLY,
     },
     "quick-draw": {
         id: "quick-draw",
         label: "Quick draw",
-        description: "Answered with a lightning-fast average time.",
+        description: "Averaged under three seconds an answer.",
         icon: "hourglass",
         modes: CROSS_MODE,
     },
@@ -185,10 +195,80 @@ export const BADGES = {
     "unbroken-focus": {
         id: "unbroken-focus",
         label: "Unbroken focus",
-        description: "Never left the trial.",
+        description: "Stayed with the trial for ten or more questions.",
         icon: "eye-1",
         modes: SOLO_ONLY,
     },
+    herculean: {
+        id: "herculean",
+        label: "Herculean",
+        description: "Answered every hard question correctly in a mixed-difficulty run.",
+        icon: "horn",
+        modes: CROSS_MODE,
+    },
+    undaunted: {
+        id: "undaunted",
+        label: "Undaunted",
+        description: "Never missed twice in a row across twelve or more questions.",
+        icon: "heart",
+        modes: CROSS_MODE,
+    },
+    measured: {
+        id: "measured",
+        label: "Measured",
+        description: "Took time to think and still kept 85% accuracy.",
+        icon: "difficulty",
+        modes: CROSS_MODE,
+    },
+    "strong-start": {
+        id: "strong-start",
+        label: "Strong start",
+        description: "Opened a run with five correct in a row.",
+        icon: "flag",
+        modes: CROSS_MODE,
+    },
+    "new-heights": {
+        id: "new-heights",
+        label: "New heights",
+        description: "Beat a best score set under the same trial settings.",
+        icon: "chevron-up",
+        modes: SOLO_ONLY,
+    },
+    "far-horizons": {
+        id: "far-horizons",
+        label: "Far horizons",
+        description: "Answered correctly in ten categories across many trials.",
+        icon: "north-star",
+        modes: SOLO_ONLY,
+    },
+    cassandra: {
+        id: "cassandra",
+        label: "Cassandra",
+        description: "Answered correctly where most of the field went wrong.",
+        icon: "eye-2",
+        modes: MULTIPLAYER_ONLY,
+    },
+    "lone-torch": {
+        id: "lone-torch",
+        label: "Lone torch",
+        description: "Stood alone with the right answer in a round.",
+        icon: "candle",
+        modes: MULTIPLAYER_ONLY,
+    },
+    ascendant: {
+        id: "ascendant",
+        label: "Ascendant",
+        description: "Climbed from the bottom half to the podium.",
+        icon: "sun",
+        modes: MULTIPLAYER_ONLY,
+    },
+    undisputed: {
+        id: "undisputed",
+        label: "Undisputed",
+        description: "Held first place from the second round to the last.",
+        icon: "sun-detail",
+        modes: MULTIPLAYER_ONLY,
+    },
 };
 // ── Thresholds ────────────────────────────────────────────────────────────────
 // Tuned so a typical run earns ~1–2 badges, not a handful — the easy-to-stack
@@ -211,13 +291,17 @@ const QUICK_DRAW_AVG_MS = 3000;
 const UNBROKEN_FOCUS_MIN_ANSWERED = 10;
 /** Per-category correct count needed to claim specialist (must be 100%). */
 const SPECIALIST_MIN_IN_CATEGORY = 4;
-/** A single answer beating more than this % of prior solvers earns faster-than-most. */
-const FASTER_THAN_MOST_PERCENT = 75;
+/** An answer beating more than this % of prior solvers counts toward Wing-footed. */
+export const FASTER_THAN_MOST_PERCENT = 75;
+/** Minimum answered for Wing-footed. */
+const WING_FOOTED_MIN_ANSWERED = 6;
+/** Fast answers needed for Wing-footed. */
+const WING_FOOTED_FAST_ANSWERS = 3;
 /** Questions answered in an endless run that earns survivor. */
 const SURVIVOR_QUESTIONS = 20;
-/** Distinct categories a run must span for the "master of none" meta-badge. */
+/** Distinct categories a run must span for the Many-sided meta-badge. */
 const MASTER_OF_NONE_MIN_CATEGORIES = 3;
-/** Other badges that must be earned alongside the breadth for "master of none". */
+/** Other badges that must be earned alongside the breadth for Many-sided. */
 const MASTER_OF_NONE_MIN_BADGES = 3;
 /** Accuracy (0–1) on a hard run that earns giant-slayer. */
 const GIANT_SLAYER_ACCURACY = 0.9;
@@ -231,8 +315,10 @@ const PHOENIX_STREAK = 5;
 const CLUTCH_REMAINING_FRACTION = 0.1;
 /** Clutch finishes needed across the run to earn the badge. */
 const CLUTCH_MIN = 3;
-/** Min answers before "sure-handed" (never changed an answer) is an achievement. */
+/** Min answers before "sure-handed" (correct before halfway) is an achievement. */
 const SURE_HANDED_MIN_ANSWERED = 8;
+/** Share of answers (0–1) that must be correct before halfway for "sure-handed". */
+const SURE_HANDED_SHARE = 0.8;
 /** Trailing consecutive-correct answers a run must end on for "strong finish". */
 const STRONG_FINISH_STREAK = 5;
 /** Per-band accuracy (0–1) each difficulty must clear for "polymath". */
@@ -241,6 +327,28 @@ const POLYMATH_BAND_ACCURACY = 0.6;
 const POLYMATH_MIN_PER_BAND = 2;
 /** Consecutive days played that earns "devotee". */
 const DEVOTEE_DAYS = 3;
+/** Prior runs in a trial bucket needed before "new-heights" is a claim. */
+const NEW_HEIGHTS_MIN_PRIOR_RUNS = 3;
+/** Distinct categories answered correctly that earns "far-horizons". */
+const FAR_HORIZONS_CATEGORIES = 10;
+/** Hard-band answers a mixed run needs before "herculean" is a claim. */
+const HERCULEAN_MIN_HARD = 4;
+/** Answers floor for "undaunted". */
+const UNDAUNTED_MIN_ANSWERED = 12;
+/** Misses a run needs before "undaunted" says anything about recovery. */
+const UNDAUNTED_MIN_MISSES = 3;
+/** Accuracy (0–1) "undaunted" needs alongside its scattered misses. */
+const UNDAUNTED_ACCURACY = 0.7;
+/** Answers floor for "measured". */
+const MEASURED_MIN_ANSWERED = 8;
+/** Accuracy (0–1) "measured" needs. */
+const MEASURED_ACCURACY = 0.85;
+/** Highest decisive share (0–1) that still reads as taking time. */
+const MEASURED_MAX_DECISIVE_SHARE = 0.3;
+/** Leading correct answers that earn "strong start". */
+const STRONG_START_STREAK = 5;
+/** Answers floor for "strong start". */
+const STRONG_START_MIN_ANSWERED = 8;
 /** Heroes a multiplayer field needs before winning it means anything. */
 const VICTOR_MIN_HEROES = 2;
 /** Highest rank that still counts as a podium finish. */
@@ -249,6 +357,88 @@ const PODIUM_MAX_RANK = 3;
 const PODIUM_MIN_HEROES = 4;
 /** Served-questions floor for the rank badges (victor, podium) and lifetime best-rank — below this a rank isn't a claim. */
 export const RANK_BADGE_MIN_QUESTIONS = 6;
+/** Others a round needs for the field to be wrong "most of" (Cassandra). */
+const CASSANDRA_MIN_OTHERS = 3;
+/** Share (0–1) of the other players who must be wrong in a Cassandra round. */
+const CASSANDRA_WRONG_SHARE = 0.6;
+/** Rounds needed for Cassandra. */
+const CASSANDRA_MIN_ROUNDS = 3;
+/** Heroes a field needs for Cassandra. */
+const CASSANDRA_MIN_HEROES = 4;
+/** Heroes a field needs for Lone torch. */
+const LONE_TORCH_MIN_HEROES = 5;
+/** Others who must have submitted an answer in a Lone torch round. */
+const LONE_TORCH_MIN_SUBMITTERS = 4;
+/** Places Ascendant must climb from the midpoint snapshot. */
+const ASCENDANT_MIN_CLIMB = 2;
+/** Per-round submitted/correct totals across every log (first row per round). */
+function tallyRounds(logs) {
+    const tallies = new Map();
+    for (const log of logs.values()) {
+        const seen = new Set();
+        for (const e of log) {
+            if (seen.has(e.questionIndex))
+                continue;
+            seen.add(e.questionIndex);
+            if (!e.submitted)
+                continue;
+            let t = tallies.get(e.questionIndex);
+            if (!t) {
+                t = { submitted: 0, correct: 0 };
+                tallies.set(e.questionIndex, t);
+            }
+            t.submitted++;
+            if (e.isCorrect)
+                t.correct++;
+        }
+    }
+    return tallies;
+}
+// Keyed by the logs map so a final-scores pass tallies once for all players.
+const tallyCache = new WeakMap();
+/**
+ * Field-relative round counts for `playerId` from every tenured player's log.
+ * The field for a round is the other players' submitted answers; a miss-filled
+ * row (a leaver, or a timeout) is not a wrong answer and is left out. Round
+ * tallies are cached per `logs` map, so `logs` must not change between calls.
+ */
+export function fieldRoundStats(playerId, logs) {
+    let tallies = tallyCache.get(logs);
+    if (!tallies) {
+        tallies = tallyRounds(logs);
+        tallyCache.set(logs, tallies);
+    }
+    let fieldRoundsDefied = 0;
+    let soleCorrectRounds = 0;
+    const own = logs.get(playerId) ?? [];
+    const firstOwn = new Map();
+    for (const e of own) {
+        if (!firstOwn.has(e.questionIndex))
+            firstOwn.set(e.questionIndex, e);
+    }
+    for (const entry of own) {
+        if (!entry.isCorrect)
+            continue;
+        const t = tallies.get(entry.questionIndex);
+        let others = t?.submitted ?? 0;
+        let othersCorrect = t?.correct ?? 0;
+        const mine = firstOwn.get(entry.questionIndex);
+        if (mine?.submitted) {
+            others--;
+            if (mine.isCorrect)
+                othersCorrect--;
+        }
+        const wrong = others - othersCorrect;
+        if (others >= CASSANDRA_MIN_OTHERS &&
+            wrong / others >= CASSANDRA_WRONG_SHARE) {
+            fieldRoundsDefied++;
+        }
+        if (othersCorrect === 0 && others >= LONE_TORCH_MIN_SUBMITTERS) {
+            soleCorrectRounds++;
+        }
+    }
+    return { fieldRoundsDefied, soleCorrectRounds };
+}
 function humanize(categoryId) {
     return categoryId.replace(/-/g, " ");
 }
@@ -325,6 +515,20 @@ function trailingStreak(input) {
     }
     return run;
 }
+/** True when any two consecutive answers were both misses. */
+function hasConsecutiveMisses(input) {
+    for (let i = 1; i < input.results.length; i++) {
+        if (!input.results[i].isCorrect && !input.results[i - 1].isCorrect) {
+            return true;
+        }
+    }
+    return false;
+}
+/** True when the run opened with `n` correct answers in a row. */
+function openedWithStreak(input, n) {
+    return (input.results.length >= n &&
+        input.results.slice(0, n).every((r) => r.isCorrect));
+}
 /**
  * True when the run spanned all three difficulty bands (each over its floor) and
  * cleared the accuracy bar in every one — a polymath. Needs per-result
@@ -440,11 +644,11 @@ export function computeBadges(input) {
     if (finish >= STRONG_FINISH_STREAK) {
         awards.push({ id: "strong-finish", detail: `${finish} to close it out` });
     }
-    if (input.fasterThanMaxPercent !== null &&
-        input.fasterThanMaxPercent > FASTER_THAN_MOST_PERCENT) {
+    if (input.totalAnswered >= WING_FOOTED_MIN_ANSWERED &&
+        input.fastAnswerCount >= WING_FOOTED_FAST_ANSWERS) {
         awards.push({
             id: "faster-than-most",
-            detail: `beat ${input.fasterThanMaxPercent}% of solvers`,
+            detail: `outran most on ${input.fastAnswerCount} questions`,
         });
     }
     // Clutch: repeatedly landed answers in the final slice of the clock.
@@ -459,26 +663,73 @@ export function computeBadges(input) {
             detail: `${(input.timeToAnswerAvgMs / 1000).toFixed(1)}s average`,
         });
     }
+    // Sure-handed: four in five answers correct before halfway. Outranks
+    // decisive, which it implies.
+    const sureHandedShare = input.timerDurationMs > 0 && input.totalAnswered >= SURE_HANDED_MIN_ANSWERED
+        ? input.results.filter((r) => r.isCorrect && r.timeToAnswerMs <= input.timerDurationMs / 2).length / input.totalAnswered
+        : 0;
+    const sureHanded = sureHandedShare >= SURE_HANDED_SHARE;
+    if (sureHanded) {
+        awards.push({
+            id: "sure-handed",
+            detail: `${percent(sureHandedShare)}% right before halfway`,
+        });
+    }
     const share = decisiveShare(input);
-    if (share !== null &&
+    if (!sureHanded &&
+        share !== null &&
         share >= DECISIVE_THRESHOLD &&
         input.totalAnswered >= RATE_BADGE_MIN_ANSWERED) {
         const pct = percent(share);
         awards.push({ id: "decisive", detail: `${pct}% before halfway` });
     }
-    // Sure-handed: committed every answer first-try, no second-guessing (STATS-7).
-    if (input.answerChanges === 0 &&
-        input.totalAnswered >= SURE_HANDED_MIN_ANSWERED) {
-        awards.push({ id: "sure-handed", detail: "no answer ever changed" });
-    }
     if (input.totalAnswered >= UNBROKEN_FOCUS_MIN_ANSWERED &&
         input.tabAwayCount === 0) {
         awards.push({ id: "unbroken-focus", detail: "never left the trial" });
     }
+    // Herculean: every hard question right in a mixed-difficulty run.
+    const hardResults = input.results.filter((r) => r.difficulty === "hard");
+    if (input.difficulty === "all" &&
+        hardResults.length >= HERCULEAN_MIN_HARD &&
+        hardResults.every((r) => r.isCorrect)) {
+        awards.push({
+            id: "herculean",
+            detail: `${hardResults.length} hard, all correct`,
+        });
+    }
+    // Undaunted: a long run whose misses never came back-to-back.
+    const misses = input.totalAnswered - input.correctCount;
+    if (input.totalAnswered >= UNDAUNTED_MIN_ANSWERED &&
+        misses >= UNDAUNTED_MIN_MISSES &&
+        accuracy >= UNDAUNTED_ACCURACY &&
+        !hasConsecutiveMisses(input)) {
+        awards.push({
+            id: "undaunted",
+            detail: `${misses} misses, never two in a row`,
+        });
+    }
+    // Measured: high accuracy while taking time on most answers.
+    if (input.totalAnswered >= MEASURED_MIN_ANSWERED &&
+        accuracy >= MEASURED_ACCURACY &&
+        share !== null &&
+        share <= MEASURED_MAX_DECISIVE_SHARE) {
+        awards.push({
+            id: "measured",
+            detail: `${percent(accuracy)}% accuracy, unhurried`,
+        });
+    }
+    // Strong start: opened the run on five correct in a row.
+    if (input.totalAnswered >= STRONG_START_MIN_ANSWERED &&
+        openedWithStreak(input, STRONG_START_STREAK)) {
+        awards.push({
+            id: "strong-start",
+            detail: `${STRONG_START_STREAK} to open`,
+        });
+    }
     // Mode tags (ADR 0018): only badges awardable in this mode survive. Applied
     // before the meta-badge so master-of-none never counts a filtered honour.
     const eligible = awards.filter((a) => BADGES[a.id].modes.includes(context.kind));
-    // Master of none (meta): broad play that still racked up honours — jack of
+    // Many-sided (meta): broad play that still racked up honours — jack of
     // all trades. Counts the badges earned *above*, so it never counts itself.
     const distinctCategories = new Set(input.results.map((r) => r.categoryId))
         .size;
@@ -489,6 +740,48 @@ export function computeBadges(input) {
             detail: `${distinctCategories} categories spanned`,
         });
     }
+    // Field badges (multiplayer): derived from the game's answer log and per-round
+    // rank snapshots. Added after the meta so they never count toward it.
+    if (context.kind === "multiplayer") {
+        const victorGates = context.score > 0 &&
+            context.heroCount >= VICTOR_MIN_HEROES &&
+            context.questionsServed >= RANK_BADGE_MIN_QUESTIONS;
+        const podiumGates = context.score > 0 &&
+            context.heroCount >= PODIUM_MIN_HEROES &&
+            context.questionsServed >= RANK_BADGE_MIN_QUESTIONS;
+        const history = context.rankHistory ?? [];
+        const defied = context.fieldRoundsDefied ?? 0;
+        const cassandra = context.heroCount >= CASSANDRA_MIN_HEROES &&
+            defied >= CASSANDRA_MIN_ROUNDS;
+        if (cassandra) {
+            eligible.push({
+                id: "cassandra",
+                detail: `right against the field ${defied}×`,
+            });
+        }
+        if (!cassandra &&
+            context.heroCount >= LONE_TORCH_MIN_HEROES &&
+            (context.soleCorrectRounds ?? 0) >= 1) {
+            eligible.push({ id: "lone-torch", detail: "only one right in a round" });
+        }
+        const mid = history[Math.floor((history.length - 1) / 2)];
+        if (podiumGates &&
+            context.rank <= PODIUM_MAX_RANK &&
+            mid &&
+            mid.rank > Math.ceil(mid.field / 2) &&
+            mid.rank - context.rank >= ASCENDANT_MIN_CLIMB) {
+            eligible.push({
+                id: "ascendant",
+                detail: `#${mid.rank} at halfway, finished #${context.rank}`,
+            });
+        }
+        if (victorGates &&
+            context.rank === 1 &&
+            history.length >= 2 &&
+            history.slice(1).every((h) => h?.rank === 1 && h.lead)) {
+            eligible.push({ id: "undisputed", detail: "first from round two" });
+        }
+    }
     // Devotee: a consistency honour for returning on consecutive days (STATS-9).
     // Cross-run, so it's gated on the player's day streak (signed-in only) rather
     // than this run's play. Added after the meta so it never counts toward it.
@@ -500,6 +793,35 @@ export function computeBadges(input) {
             detail: `${input.consecutiveDays} days running`,
         });
     }
+    // New heights: a personal best in the same trial bucket, after enough prior
+    // runs to make it a claim. Cross-run, so appended after the meta-count.
+    if (context.kind === "solo" &&
+        context.mode === "normal" &&
+        input.runScore !== undefined &&
+        input.bucketBest != null &&
+        (input.bucketPriorRuns ?? 0) >= NEW_HEIGHTS_MIN_PRIOR_RUNS &&
+        input.runScore > input.bucketBest) {
+        eligible.push({
+            id: "new-heights",
+            detail: `${input.runScore} beat ${input.bucketBest}`,
+        });
+    }
+    // Far horizons: awarded once, on the run that lifts the player's distinct
+    // correctly-answered categories to the threshold.
+    if (context.kind === "solo" && input.priorCorrectCategories !== undefined) {
+        const prior = new Set(input.priorCorrectCategories);
+        const total = new Set(prior);
+        for (const r of input.results)
+            if (r.isCorrect)
+                total.add(r.categoryId);
+        if (prior.size < FAR_HORIZONS_CATEGORIES &&
+            total.size >= FAR_HORIZONS_CATEGORIES) {
+            eligible.push({
+                id: "far-horizons",
+                detail: `${total.size} categories mastered`,
+            });
+        }
+    }
     const rank = new Map(BADGE_ORDER.map((id, i) => [id, i]));
     return (eligible
         // The mode tags are the authoritative gate (ADR 0018): a final pass so
@@ -514,17 +836,6 @@ export const RARITY_LABELS = {
     legendary: "Legendary",
     exotic: "Exotic",
 };
-/**
- * Canonical tier colours, shared by every surface that renders the rarity
- * scale (badge chips, legends) so the key always matches the badges it
- * explains.
- */
-export const RARITY_CHIP_CLASSES = {
-    common: "border-zinc-500/40 bg-zinc-500/10 text-zinc-200",
-    rare: "border-blue-500/40 bg-blue-500/10 text-blue-200",
-    legendary: "border-violet-500/50 bg-violet-500/10 text-violet-200",
-    exotic: "border-gold bg-gold/20 text-gold-lighter shadow-[0_0_12px_-2px] shadow-gold/40",
-};
 const RARITY_RULES = {
     victor: { base: 1, heroes: true, difficulty: true },
     podium: { base: 0, heroes: true, difficulty: true },
@@ -553,15 +864,30 @@ const RARITY_RULES = {
         timer: "shorter",
         difficulty: true,
     },
-    "sure-handed": { base: 1, questions: true, difficulty: true },
+    "sure-handed": {
+        base: 1,
+        questions: true,
+        timer: "shorter",
+        difficulty: true,
+    },
     devotee: { base: 1 },
     phoenix: { base: 1, difficulty: true },
     "master-of-none": { base: 2, difficulty: true },
     clutch: { base: 1, questions: true, difficulty: true },
-    "faster-than-most": { base: 1, timer: "shorter", difficulty: true },
+    "faster-than-most": { base: 1, difficulty: true },
     "quick-draw": { base: 1, questions: true, timer: "longer", difficulty: true },
     decisive: { base: 0, questions: true, timer: "shorter", difficulty: true },
     "unbroken-focus": { base: 0, questions: true, difficulty: true },
+    herculean: { base: 2, difficulty: true },
+    undaunted: { base: 0, questions: true, difficulty: true },
+    measured: { base: 0, questions: true, difficulty: true },
+    "strong-start": { base: 0, timer: "shorter", difficulty: true },
+    "new-heights": { base: 1, difficulty: true },
+    "far-horizons": { base: 1 },
+    cassandra: { base: 1, heroes: true, difficulty: true },
+    "lone-torch": { base: 0, heroes: true, difficulty: true },
+    ascendant: { base: 1, heroes: true },
+    undisputed: { base: 2, heroes: true, difficulty: true },
 };
 /** More questions than the default 10 → harder to sustain (0–2). */
 function questionLevel(count) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@orakl/shared",
-  "version": "0.1.0",
+  "version": "0.3.0",
   "description": "Orakl runtime helpers shared by the web client and the engine.",
   "license": "AGPL-3.0-only",
   "repository": {
@@ -17,8 +17,8 @@
   },
   "types": "./dist/index.d.ts",
   "dependencies": {
-    "@orakl/protocol": "0.1.0",
-    "date-fns": "^4.4.0"
+    "date-fns": "^4.4.0",
+    "@orakl/protocol": "0.2.0"
   },
   "devDependencies": {
     "@types/node": "^26.4.1",